RioNeti Class Reference

#include <RioNeti.h>

Data Structures
struct	Log_Arrival
Public Member Functions
	RioNeti (bool serverInstance)
	~RioNeti ()
int	Start (int port, int maxdiskl, int maxpktl, unsigned int MaxClientsCredits, unsigned int MaxNetworkCredits, unsigned int NetworkRate)
int	Stop ()
void	allocMappingVectors (int size)
void	getmyaddrport (int *ipaddr, int *port, int server=0)
void	getalladdrport (int **ipaddr, int **port)
int	getipaddr ()
void	SetCmdProc (cmdcallback_t cmdproc, void *cmdparm)
	Este m�todo n�o est� sendo usado em lugar nenhum do c�digo.
void	SendCmd (int ipadr, int port, int reqid, char *cmdp, int cmdl, callback_t callback, void *callbackparm)
	SendCmd -- send a command to target ip/port multiple of these can be in progress to the same target.
void	SendData (int ipadr, int port, int reqid, char *bufadr, int buflen, callback_t callback, void *callbackparm, int StreamTraffic, unsigned int VideoRate=0, unsigned int *sendreqid=NULL)
int	ExpectData (char *buf, int len, callback_t callback, void *callbackparm, RioStreamType traffic, int sendack=1)
	ExpectData - Establish an endpoint here for data to be sent to.
int	ExpectCmd (callback_t callback, void *callbackparm, cmdcallback_t cmdcallback)
int	CancelExpect (int reqid, int result)
void	SendResult (int ipadr, int port, int reqid, int result, callback_t callback, void *callbackparm)
void	SendRst (int ipaddr, int port, int reqid, int result)
	Esta funcao, que antes era private, agora passou a ser public para permitir que enviemos um erro para cancelar um pedido pendende.
void	CreateMulticastSocket (int sockIndex)
	CreateMulticastSocket fecha o socket multicast indicado por sockIndex e abre um novo socket multicast.
bool	SetMulticastSocket (unsigned short multicastport, char *multicast_addr, void *callback=0, BufferStream *buffer_stream=0, int enable_join=1)
	SetMulticastSocket cria um novo socket multicast com as informa��es recebidas nos par�metros multicastport e multicast_addr.
void	LeaveGroup (unsigned short multicastport)
	LeaveGroup descobre a qual membro da matriz multicastInfo o par�metro multicastport est� associado e fecha o socket respectivo, limpando os demais membros desta estrutura.
void	LeaveAllGroups (void)
int	FreeBlock (unsigned int block_id, RioStreamType traffic)
	FreeBlock recupera os fragmentos dispon�veis do bloco indicado pelo par�metro block_id para exibi��o imediata no cliente.
int	FreePendentBlocks (bool useCache, int nBuffers)
	FreePendentBlocks procura por blocos que come�aram a ser recebidos h� bastante tempo mas que por perdas na rede n�o foram completamente recebidos.
bool	thereAreFragments (RioBlock block)
	thereAreFragments verifica se existem fragmentos do bloco block_id e retorna true caso encontre algum fragmento para este bloco ou false caso contr�rio.
int	CreateKeepaliveThread (void)
	CreateKeepaliveThread funcao para criar a thread usada para enviar periodicamente mensagens Fake aos servidores para garantir que os mapeamentos nao serao expirados por timeout.
bool	IsBehindNAT ()
	IsBehindNAT esta funcao retorna true se o cliente estiver atras de um NAT, caso a funcao RequestMapping tenha sido chamada pelo cliente para obter o mapeamento, e false caso o cliente nao esteja atras do NAT ou se a funcao RequestMapping nao tenha sido chamada.
void	RequestMapping (int ipaddr, int port, int server, callback_t callback, void *callbackparm)
	RequestMapping faz uma requisicao a um outro objeto RioNeti, pedindo o mapeamento, isto e, o endereco IP e a porta visivel por este objeto.
int	nbSend (NetBuf *rp, char *FragmentData=NULL, int FragmentSize=0, int IP=0, int Port=0)
	nbSend funcao para enviar um objeto NetBuf pela rede (antiga funcao iSend), se rp for diferente de NULL, e o fragmento dado pelos parametros de 2 ate 5, se rp for igual a NULL.
void	setLogRotation (CLogRotation *LogRotation)
	Funcao para definir o objeto (do tipo CLogRotation) a ser usado para armazenas as estatisticas de envio de pacotes.
bool	CancelCopyBlock (int reqid, int result)
	Funcao para cancelar o pedido de um bloco, removendo ele das filas internas e chamando a callback do cliente.
Private Types
enum	call_type {   TYPE_RST, TYPE_CMD, TYPE_RESULT, TYPE_ACK,   TYPE_FRAG, TYPE_FRAGACK, TYPE_TIMEOUT, TYPE_CANCEL,   TYPE_SENDMAP, TYPE_MAPACK }
Private Member Functions
void	HashMutexLock (string msg="")
void	HashMutexUnlock (string msg="")
void	iOutAdd (NetBuf *nbp, void(*outrtn)(NetBuf *))
void	iOutAddTop (NetBuf *nbp, void(*outrtn)(NetBuf *))
void	iOutRmv (NetBuf *nbp)
void	iHashNew (NetBuf *nbp)
void	iHashRmv (NetBuf *nbp)
NetBuf *	iHashFind (int reqid)
NetBuf *	iHashFindRst (int ip, int port, int reqid)
void	prtHash (const char *)
void	SetTTLValue (int socket, char ttl)
void	SetLoopBack (int socket, char loop)
void	JoinGroup (int sockIndex, char *group_addr)
	JoinGroup envia uma mensagem pra rede (roteadores) informando que o socket multicast de �ndice sockIndex deseja entrar no grupo multicast indicado em multicastInfo[sockIndex].myaddr_in.
NetBuf *	pSend (int ipadr, int port, int reqid, call_type type)
void	qSend (NetBuf *nbp)
int	iSend (NetBuf *nbp)
	iSend funcao para enviar um objeto NetBuf pela rede.
void	iSendFragBuild (NetBuf *nbp, int fragnum)
int	iSendFragNext (NetBuf *nbp)
void	iSendAck (int ipaddr, int port, int reqid)
void	qComplete (NetBuf *nbp, int result)
	qComplete chama a CallBack do cliente indiretamente: seta vari�veis que a NetMgrThread fica analisando continuamente em um loop de forma que a NetMgrThread perceba que o bloco j� est� pronto para ser executado e, consequentemente, chame a CallBack do cliente.
int	iRetry (NetBuf *nbp)
void	SocketMulticastLock (string msg="")
	SocketMulticastLock trava o mutex socketMulticastMutex.
void	SocketMulticastUnlock (string msg="")
	SocketMulticastUnlock destrava o mutex socketMulticastMutex.
void	iTimeNew (NetBuf *nbp, int interval)
void	iTimeRmv (NetBuf *nbp)
NetBuf *	mbget ()
void	mbfree (NetBuf *bf)
void	NetMgrThread (void)
void	restartreq (NetBuf *)
void	procpkt (NetBuf **rcvbuf, RioStreamType traffic=UNICASTTRAFFIC)
void	procpktrst (char *pktp, int pktl)
void	procpktfrag (char *pktp, int pktl, RioStreamType traffic=UNICASTTRAFFIC)
void	procpktfragack (char *pktp, int pktl)
void	dispsockopt (int)
void	mucksockopt (int fd)
void	prtcnt ()
void	prttim (const char *s)
void	mbinit (int num)
void	mbterm ()
int	FindMulticastReqid (int multicastreqid)
int	InsertMulticastReqid (int multicastreqid, int localreqid)
int	DeleteMulticastReqid (int localreqid)
	DQUEUE (NetBuf) xm_timeq
int	findNetInterface ()
void	iSendMapAck (int ipaddr, int port, int reqid)
	iSendMapAck Envia um ACK de uma requisicao por mapeamento para o IP ipaddr e a porta port.
Static Private Member Functions
static void	fSend (NetBuf *nbp)
static void	gSend (NetBuf *nbp)
static void	iSendFrag (NetBuf *nbp)
static void	iSendFragAck (NetBuf *nbp)
static void	CleanupNetMgrThread (void *)
static void *	NetMgrThreadEp (void *parm)
static void	sendcmdcb (NetBuf *nbp, int type, char *cmdp, int cmdl)
static void	sendblockcb (NetBuf *nbp, int type, char *cmdp, int cmdl)
static void	expectblockcb (NetBuf *nbp, int type, char *cmdp, int cmdl)
static void	dummyusercb (void *parm, int result)
static void	procretry (struct td4_tim *)
static void *	KeepaliveMapNAT (void *)
	KeepaliveMapNAT funcao para a thread usada para enviar periodicamente mensagens Fake aos servidores para garantir que os mapeamentos nao serao expirados.
Private Attributes
unsigned int	numPkts
pthread_t	mThread
int	m_debug
RioNetiReqIdTable *	reqid_table
BufferStream *	buffer_stream
callback_t	callback
RioCallBackTransport *	callback_transport
bool	serverInstance
int	max_in_set
struct MulticastInfo	multicastInfo [MULTICAST_SOCKETS]
pthread_mutex_t	socketMulticastMutex
struct sockaddr_in	myAddress
int	m_sock
pthread_t	m_thread
pthread_mutex_t	HashMutex
pthread_mutex_t	m_buf_lock
pthread_mutex_t	m_dns_lock
pthread_mutex_t	m_TcpLock
pthread_t	m_TcpServerThread
int	m_ipaddr
int	m_ipport
int *	m_ipaddrmap
int *	m_ipportmap
bool	m_behindnat
pthread_t	m_threadmap
struct NATMappingInfo *	m_MappingInfo
unsigned int	m_MappingInfoSize
int	m_maxpktl
int	m_maxdiskl
int	m_threadstop
int	m_toaddrl
int	m_fraddrl
cmdcallback_t	m_cmdproc
void *	m_cmdparm
struct sockaddr_in	m_fraddr
struct sockaddr_in	m_toaddr
int	cnt_sndpkt
int	cnt_rcvpkt
int	cnt_retry
int	cnt_rst1
int	cnt_rst2
int	cnt_rcvfragack
int	cnt_rcvfragacknc
int	err_dupfrag
int	err_overfrag
int	err_pktsize
int	err_pktmagic
int	err_pktnoreq
int	err_pktcmd
int	err_pktfmt
int	xm_rstsec
int	xm_rstip
int	xm_rstport
int	xm_rstreqid
NetBuf *	m_cmpltf
NetBuf *	m_cmpltl
NetBuf *	m_outqf
NetBuf *	m_outql
struct timeval	xm_now
struct timeval	next
fd_set *	writefdsp
fd_set	readfds
fd_set	writefds
NetBuf *	mbc_free
int	mbc_num
int	reqseq
NetBuf *	reqarray [XM_REQNUM]
CStreamControl *	m_StreamControl
CLogRotation *	m_LogRotation
Static Private Attributes
static const int	DEBUG_CNT = (1 << 0)
static const int	DEBUG_FRAG = (1 << 2)
static const int	DEBUG_TIM = (1 << 3)
static const int	DEBUG_DATA = (1 << 4)
static const int	DEBUG_CMDS = (1 << 5)
static const int	DEBUG_MISC = (1 << 6)
static const int	DEBUG_MORE = (1 << 8)
static const int	DEBUG_TIMEOUT = (1 << 10)
static const int	TimeShift = 10
static const int	XM_REQBITS = 8
static const int	XM_REQNUM = (1 << XM_REQBITS)
static const int	XM_REQMASK = (XM_REQNUM-1)
static debugCerr	m_log

---

Detailed Description

Definition at line 188 of file RioNeti.h.

---

Member Enumeration Documentation

enum RioNeti::call_type [private]

Enumerator:

TYPE_RST
TYPE_CMD
TYPE_RESULT
TYPE_ACK
TYPE_FRAG
TYPE_FRAGACK
TYPE_TIMEOUT
TYPE_CANCEL
TYPE_SENDMAP
TYPE_MAPACK

Definition at line 191 of file RioNeti.h.

    { 
        TYPE_RST,
        TYPE_CMD,
        TYPE_RESULT,
        TYPE_ACK,
        TYPE_FRAG,
        TYPE_FRAGACK,
        TYPE_TIMEOUT, 
        TYPE_CANCEL,
        TYPE_SENDMAP, 
        TYPE_MAPACK
    };

---

Constructor & Destructor Documentation

RioNeti::RioNeti

(

bool

serverInstance

)

Definition at line 169 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "[RioNeti - Construtor] Start" << endl;
    #endif

    this->serverInstance = serverInstance;
    reqid_table          = new RioNetiReqIdTable();
    m_maxpktl            = FRAGMENTSIZE;
    m_maxdiskl           = 128 * 1024;
    m_threadstop         = 1;        // no thread yet
    buffer_stream        = NULL;
    callback             = NULL;
    callback_transport   = NULL;
    m_thread             = 0;
    // m_threadstop does not need to be initialized
    m_cmdparm            = NULL;
    xm_rstsec            = 0;
    xm_rstip             = 0;
    xm_rstport           = 0;
    xm_rstreqid          = 0;
    mbc_num              = 0;
    memset( &readfds, 0, sizeof( fd_set ) );
    memset( &writefds, 0, sizeof( fd_set ) );
    reqseq               = 0;

    pthread_mutex_init( &socketMulticastMutex, NULL );

    /* Socket initialization */
    m_sock = 0;
    for( int socki = 0; socki < MULTICAST_SOCKETS; socki++ )
    {
        multicastInfo[socki].socket      = 0;
        multicastInfo[socki].isConnected = false;
        memset( &(multicastInfo[socki].myaddr_in), 0,
                sizeof( multicastInfo[socki].myaddr_in ) );
        memset( &(multicastInfo[socki].remoteaddr_in), 0,
                sizeof( multicastInfo[socki].remoteaddr_in ) );
    }

    #ifdef WINDOWS
    /* Windows implementation */
        HashMutex = CreateMutex( NULL, FALSE, NULL );
        m_buf_lock  = CreateMutex( NULL, FALSE, NULL );
        m_dns_lock  = CreateMutex( NULL, FALSE, NULL );
    #else
    /* Linux implementation */
        pthread_mutex_init( &HashMutex, NULL );
        pthread_mutex_init( &m_buf_lock, NULL );
        pthread_mutex_init( &m_dns_lock, NULL );
    #endif

    m_toaddrl           = sizeof( m_toaddr );
    memset( &m_toaddr, 0, sizeof( m_toaddr ) );
    m_toaddr.sin_family = AF_INET;
    m_fraddrl           = sizeof( m_fraddr );
    memset( &m_fraddr, 0, sizeof( m_fraddr ) );
    m_fraddr.sin_family = AF_INET;
    m_cmdproc           = 0;
    cnt_sndpkt          = 0;
    cnt_rcvpkt          = 0;
    cnt_retry           = 0;
    cnt_rst1            = 0;
    cnt_rst2            = 0;
    cnt_rcvfragack      = 0;
    cnt_rcvfragacknc    = 0;
    err_dupfrag         = 0;
    err_overfrag        = 0;
    err_pktsize         = 0;
    err_pktmagic        = 0;
    err_pktnoreq        = 0;
    err_pktcmd          = 0;
    err_pktfmt          = 0;

    for( int i = 0; i < XM_REQNUM; i++ )
        reqarray[ i ] = NULL;

    DQUEUE_INIT(xm_timeq, NetBuf, nb_tidq);
    m_cmpltf     = NULL;
    m_cmpltl     = VIRTORG(m_cmpltf, NetBuf, nb_link);
    m_outqf      = NULL;
    m_outql      = VIRTORG(m_outqf, NetBuf, nb_outnext);
    mbc_free     = NULL;
    m_debug      = 0;


    // Inicializacao das variaveis criadas para dar suporte aos clientes atras
    // de NAT.
    m_threadmap = 0;
    // Inicializa as estruturas usadas pelo mapeamento.
    m_MappingInfo = NULL;
    m_MappingInfoSize = 0;
    m_ipaddrmap = NULL;
    m_ipportmap = NULL;

    // Inicializa o ponteiro para o objeto para o controle de fluxo.
    m_StreamControl = NULL;
    
    // Inicializa o ponteiro para o objeto que armazena os logs com os pacotes
    // enviados.
    m_LogRotation = NULL;
    
    #ifdef RIO_DEBUG1
    RioErr << "[RioNeti - Construtor] Finish" << endl;
    #endif
}

RioNeti::~RioNeti

(

)

Definition at line 277 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - Destructor] Start" << endl;
    #endif

    if( !m_threadstop )
        Stop();

    #ifdef WINDOWS
        // Windows implementation
        CloseHandle( HashMutex );
        CloseHandle( m_buf_lock  );
        CloseHandle( m_dns_lock  );
        CloseHandle( m_thread    );
    #else
        // Linux implementation
        pthread_mutex_destroy( &HashMutex );
        pthread_mutex_destroy( &m_buf_lock  );
        pthread_mutex_destroy( &m_dns_lock  );
    #endif

    delete reqid_table;

    // Verifica se criamos um objeto de log, para o removermos em caso 
    // afirmativo.
    if( m_StreamControl != NULL )
        delete m_StreamControl;

    // Verifica se criamos um objeto de controle de fluxo, para o removermos
    // em caso afirmativo.
    if( m_LogRotation != NULL )
        delete m_LogRotation;

    if( ( m_ipaddrmap != NULL ) && ( m_ipaddrmap != ( &m_ipaddr ) ) ) 
        delete m_ipaddrmap;

    if( ( m_ipportmap != NULL ) && ( m_ipportmap != ( &m_ipport ) ) )
        delete m_ipportmap;

    if( m_MappingInfo != NULL )
        delete m_MappingInfo;

    // Remove todos os NetBuf criados e disponiveis na fila.
    mbterm();

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - Destructor] Finish" << endl;
    #endif
}

---

Member Function Documentation

void RioNeti::allocMappingVectors

(

int

size

)

Definition at line 333 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - allocMappingVectors] Start" << endl;
    #endif

    m_ipaddrmap = new int[ size ];
    m_ipportmap = new int[ size ];
    m_MappingInfo = new NATMappingInfo[ size ];
    m_MappingInfoSize = size;
    // Faltou inicializar o vetor com o IP e a porta local do cliente (para
    // corretamente verificar se estamos ou nao atras de NAT).
    for( int i = 0; i < size; i++ )
    {
        m_ipaddrmap[ i ] = -1;
        m_ipportmap[ i ] = 0;
        m_MappingInfo[ i ].IsEnabled = false;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - allocMappingVectors] Finish" << endl;
    #endif
}

bool RioNeti::CancelCopyBlock	(	int	reqid,
		int	result
	)

Funcao para cancelar o pedido de um bloco, removendo ele das filas internas e chamando a callback do cliente.

Parameters:

	reqid	identificador do bloco (o NetBuf).
	result	erro a ser passado a callback. se o cancelamento foi feito com sucesso, e fase caso a reqid esteja associada a um bloco que nao existe.

Definition at line 6084 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CancelCopyBlock] Start" << endl;
    #endif

    NetBuf *nbp;
    bool status;

    HashMutexLock( "cancelcopyblock" );
    
    // Procura pelo NetBuf associado a reqid passada como parametro.
    nbp = iHashFind( reqid );

    if( nbp != NULL )
    {
        // Chama a funcao para terminar o envio do bloco.
        qComplete( nbp, result );
        status = true;
    }
    else
        status = false;

    HashMutexUnlock( "cancelcopyblock" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CancelCopyBlock] Finish" << endl;
    #endif
    
    return status;
}

int RioNeti::CancelExpect	(	int	reqid,
		int	result
	)

Definition at line 5067 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CancelExpect] Start" << endl;
    #endif

    NetBuf *nbp;

    HashMutexLock( "cancelexpct" );

    nbp = iHashFind( reqid );

    // if not on hash list, just return
    if( nbp == 0 )
    {
        #ifdef RIO_DEBUG2
        m_log << "[RioNeti] CancelExpect - Tentativa de remoção do bloco de reqid "
               << reqid << " da tabela Hash falhou: bloco não encontrado." << endl;
        #endif

        goto unlockret;
    }

    iHashRmv(nbp);
    iOutRmv(nbp);
    iTimeRmv(nbp);
    mbfree( nbp );

unlockret:

    HashMutexUnlock( "cancelexpct" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CancelExpect] Finish" << endl;
    #endif

    return 1;

    //TODO: fazer este metodo ser do tipo void, preferencialemnte, ou
    //booleano pra retornar true em caso de sucesso no cancelamento do bloco. O
    //que nao pode eh ele retornar 1 sempre.
}

void RioNeti::CleanupNetMgrThread

(

void *

arg

)

[static, private]

Definition at line 1909 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CleanupNetMgrThread] Single" << endl;
    #endif
}

int RioNeti::CreateKeepaliveThread

(

void

)

CreateKeepaliveThread funcao para criar a thread usada para enviar periodicamente mensagens Fake aos servidores para garantir que os mapeamentos nao serao expirados por timeout.

Returns:

0 se a thread foi criada com sucesso, e diferente de 0 se algum erro ocorreu ao criar a thread.

Definition at line 5886 of file RioNeti.cpp.

{
    pthread_attr_t attribKeepalive;
    int erro;
    unsigned int i;
    struct sockaddr_in Server;
    // A mensagem Fake e composta por um unico caractere, para minimizar o
    // uso dos recursos da rede.
    const char *FakeMsg = "f";
    int FakeMsgSize = 1;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CreateKeepaliveThread] Start" << endl;
    #endif

    // Envia as primeiras mensagens de FAKE para os servidores.
    for( i = 0; i < m_MappingInfoSize; i++ )
    {
        if( m_MappingInfo[ i ].IsEnabled )
        {
            Server.sin_family = AF_INET;
            Server.sin_port = m_MappingInfo[ i ].port;
            Server.sin_addr.s_addr = m_MappingInfo[ i ].IP;
            sendto( m_sock, FakeMsg, FakeMsgSize, 0, 
                   (const struct sockaddr *)&Server, sizeof( Server ) );
        }
    }
    // Inicializa os atributos da thread a ser criada.
    erro = pthread_attr_init( &attribKeepalive );
    if( erro )
    {
        m_log << "RioNeti::CreateKeepaliveThread erro ao executar a funcao "
               << "pthread_attr_init, erro = " << erro << endl;
 
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - CreateKeepaliveThread] Finish1" << endl;
        #endif

        return erro;       
    } 
    
    erro = pthread_attr_setstacksize( &attribKeepalive,  2*PTHREAD_STACK_MIN );
    if( erro )
    {
        m_log << "RioNeti::CreateKeepaliveThread erro ao executar a funcao "
               << "pthread_attr_setstacksize, erro = " << erro << endl;
 
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - CreateKeepaliveThread] Finish2" << endl;
        #endif

        return erro;       
    }
     
    // Cria a thread.
    erro = pthread_create( &m_threadmap, &attribKeepalive, 
                           KeepaliveMapNAT, (void *)this );
    if( erro )
    {
        m_log << "RioNeti::CreateKeepaliveThread erro ao executar a funcao "
               << "pthread_create para criar a thread, erro = " << erro 
               << endl;
 
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - CreateKeepaliveThread] Finish3" << endl;
        #endif

        return erro;       
    }
 
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CreateKeepaliveThread] Finish4" << endl;
    #endif

    return 0;
}

void RioNeti::CreateMulticastSocket

(

int

sockIndex

)

CreateMulticastSocket fecha o socket multicast indicado por sockIndex e abre um novo socket multicast.

Neste ponto n�o � dado FD_SET nem FD_CLR pois a NetMgrThread faz isto antes de chamar select no seu loop. Nota 1: Quem seta o socket com os atributos devidos � participa��o no grupo multicast � o m�todo JoinGroup, que � chamado pelo m�todo SetMulticastSocket, ambos desta mesma classe. Nota 2: Este m�todo n�o precisa usar SocketMulticastLock() nem SocketMulticastUnlock() pois est� sendo chamado pela SetMulticastSocket() que j� faz as respectivas chamadas.

Parameters:

sockIndex

indice de uma posicao livre no vetor multicastInfo a ser usado para a criacao deste novo socket multicast.

Definition at line 848 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CreateMulticastSocket] Start" << endl;
    #endif

    int rc;

    // Create socket udp
    if( multicastInfo[sockIndex].socket )
    {
        #ifdef RIO_DEBUG2
        m_log << "CLOSING SOCKET" << endl;
        #endif

        rc = close( multicastInfo[sockIndex].socket );

        if( rc != 0 )
            Rioperror( "Failed to close socket" );
    }

    multicastInfo[sockIndex].socket = socket( AF_INET, SOCK_DGRAM,
                                              IPPROTO_UDP );

    //FIXME: A SetMulticastSocket, que é o único método que chama este método
    //CreateMulticastSocket, já seta o membro isConnected. Este método aqui
    //deveria retornar true ou false e, em caso de false, a própria
    //SetMulticastSocket é quem deveria setar isConnected pra false e limpar
    //os demais membros de multicastInfo[sockIndex].
    if( multicastInfo[sockIndex].socket < 0 )
    {
        m_log << " Error creating socket to transmite multicast"
                  " traffic " << endl;

        multicastInfo[sockIndex].isConnected = false;
    }
    else
    {
        multicastInfo[sockIndex].isConnected = true;
    }

    #ifdef RIO_DEBUG2
    m_log << "CreateMulticastSocket: socket " << sockIndex
           << " criado com porta "
           << ntohs( multicastInfo[sockIndex].myaddr_in.sin_port ) << endl;
    #endif

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - CreateMulticastSocket] Finish" << endl;
    #endif
}

int RioNeti::DeleteMulticastReqid

(

int

localreqid

)

[private]

void RioNeti::dispsockopt

(

int

fd

)

[private]

Definition at line 5596 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - dispsockopt] Start" << endl;
    #endif

    int opt;

    #ifdef WINDOWS
    // Windows implementation
    int optlen = sizeof(opt);
    if( getsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char FAR*)&opt, &optlen) )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - dispsockopt] Finish 1" << endl;
        #endif

        return;
    }
    optlen = sizeof(opt);
    if( getsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char FAR*)&opt, &optlen) )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - dispsockopt] Finish 2" << endl;
        #endif

        return;
    }
    #else
    // Linux implementation
    socklen_t optlen = sizeof(opt);
    if( getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &opt, &optlen) )
    {
        Rioperror( "getsockopt SO_SNDBUF" );

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - dispsockopt] Finish 3" << endl;
        #endif

        return;
    }
    m_log << " \tSO_SNDBUF " << opt << endl;
    optlen = sizeof(opt);
    if( getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &opt, &optlen) )
    {
        Rioperror( "getsockopt SO_RCVBUF" );

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - dispsockopt] Finish 4" << endl;
        #endif

        return;
    }
    m_log << " \tSO_RCVBUF " << opt << endl;
    #endif

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - dispsockopt] Finish 5" << endl;
    #endif
}

RioNeti::DQUEUE

(

NetBuf

)

[private]

static void RioNeti::dummyusercb	(	void *	parm,
		int	result
	)			[static, private]

void RioNeti::expectblockcb	(	NetBuf *	nbp,
		int	type,
		char *	cmdp,
		int	cmdl
	)			[static, private]

Definition at line 4973 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - expectblockcb] Start" << endl;
    #endif

    RioNeti *netiPtr = nbp->nb_rioneti;
    switch( (call_type) type )
    {
        case TYPE_RESULT:

            #ifdef RIO_DEBUG2
            m_log << "expectblockcb1 nbp->nb_result " << nbp->nb_result
                   << endl;
            #endif

            netiPtr->qComplete( nbp, ntohl( *(u32 *)cmdp ) );
            break;

        default:

            #ifdef RIO_DEBUG2
            m_log << "expectblockcb2 nbp->nb_result " << nbp->nb_result
                   << endl;
            #endif

            // must be error
            netiPtr->qComplete( nbp, ERROR_RIONETI + 1 );
            break;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - expectblockcb] Finish" << endl;
    #endif
}

int RioNeti::ExpectCmd	(	callback_t	callback,
		void *	callbackparm,
		cmdcallback_t	cmdcallback
	)

Definition at line 5022 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - Constructor] Start" << endl;
    #endif

    NetBuf *nbp;
    int reqid;

    nbp = mbget();
    nbp->nb_usercall = callback;
    nbp->nb_userparm = callbackparm;
    nbp->nb_usercmd  = cmdcallback;
    nbp->nb_callback = &expectblockcb;

    HashMutexLock( "expctcmd" );

    iHashNew( nbp );

    reqid = nbp->nb_reqid;

    HashMutexUnlock( "expctcmd" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - Constructor] Finish" << endl;
    #endif

    return reqid;
}

int RioNeti::ExpectData	(	char *	buf,
		int	len,
		callback_t	callback,
		void *	callbackparm,
		RioStreamType	traffic,
		int	sendack = 1
	)

ExpectData - Establish an endpoint here for data to be sent to.

Returns the request id for this expecting endpoint. The callback routine will be called once the data is in buf or if the operation fails. (could return whole endpoint info - ip, port, reqid, {?auth?}).

There is no timeout on an ExpectData. The caller can use CancelExpect to terminate an expect which isn't needed anymore.

### there is a timing window where a cancel expect could cancel the wrong endpoint (endpoint ends normally and a new one is created with the same reqid just as a cancelexpect is done on the old == new reqid). eh um ponteiro para a regiao de memoria onde deve ser gravado o bloco quando ele chegar. eh o tamanho do buffer apontado pelo parametro bufadr

Parameters:

	callback	eh um ponteiro para a callback do cliente.
	callbackparm	eh um ponteiro para a RioRequest do cliente relativa a este bloco.

Definition at line 4890 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - ExpectData] Start" << endl;
    #endif

    NetBuf *nbp;
    int     reqid;

    nbp = mbget();

    // ### could use internal buffer if buf supplied is 0 (with it's length)?
    nbp->nb_blockp           = bufadr;
    nbp->nb_blockl           = buflen;

    nbp->nb_usercall         = callback;
    nbp->nb_userparm         = callbackparm;
    nbp->nb_callback         = &expectblockcb;

    if( traffic == UNICASTTRAFFIC )
        nbp->nb_unicastRequested = true;
    else
        nbp->nb_unicastRequested = false;

    //Quando o fragmento 0 de um bloco chega, seu parametro nb_frag0arrive eh
    //setado para a hora em que isto ocorre. Em alguns casos o fragmento zero
    //nao chega (por perda) e seria prejudicial ao controle de blocos pendentes
    //se a hora de chegada nao estiver setada. Como nao podemos seta-la como
    //zero aqui(ja que a hora e dada em numero de segundos desde 1743) entao a
    //setamos para 10 segundos a frente (now + 10). Com isto, quando a
    //FreePendentBlocks achar um bloco que ja estourou o tempo de chegada cujo
    //fragmento zero nao chegou entao ela sabera que ele ja teve mais de 10
    //segundos desde sua requisicao ate aquele momento.
    nbp->nb_frag0arrive      = time( NULL ) + 10;

    /*not send ack*/
    if( sendack != 0 )
        nbp->nb_sendack = 1;
    else
        nbp->nb_sendack = 0;

    nbp->rq_needack     = NetBuf::RQ_ACKEVERY; // ack every Nth fragment
    nbp->rq_fragmax     = 0;
    nbp->rq_fraghav     = 0;
    nbp->rq_fraghigh    = 0;
    nbp->rq_fraglow     = 0;
    nbp->rq_fragackseq  = 0;
    nbp->rq_fraglist[0] = 0;
    memset( nbp->rq_bits, 0, sizeof( nbp->rq_bits ) );

    HashMutexLock( "expectdata" );

    //iHashNew cria um índice na tabela Hash e o associa ao NetBuffer que é
    //passado como parâmetro (setando seu parâmetro nb_reqid).
    iHashNew( nbp );

    #ifdef RIO_DEBUG2
    if( nbp->nb_unicastRequested )
        m_log << "     [RioNeti] expectdata - Inserido bloco unicast de reqid "
               << nbp->nb_reqid << " na tabela Hash." << endl;
    else
        m_log << "     [RioNeti] expectdata - Inserido bloco multicast de"
               << " reqid " << nbp->nb_reqid << " na tabela Hash." << endl;
    #endif

    reqid = nbp->nb_reqid;

    HashMutexUnlock( "expectdata" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - ExpectData] Finish" << endl;
    #endif

    return reqid;
}

int RioNeti::FindMulticastReqid

(

int

multicastreqid

)

[private]

int RioNeti::findNetInterface

(

)

[private]

Definition at line 775 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - findNetInterface] Start" << endl;
    #endif

    struct if_nameindex *iflist   = NULL;
    struct if_nameindex *listsave = NULL;
    struct ifreq         ifreq;
    int                  auxsock  = 0;
    struct sockaddr_in   sa;
    char                 localhost_ip[IP_STRING_SIZE] = "";

    if( ( auxsock = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
    {
        Rioperror( "RM_initialize: socket for ioctl" );

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - findNetInterface] Finish 1" << endl;
        #endif

        exit(1);
    }

    // returns pointer to dynamically allocated list of structs
    listsave = if_nameindex();
    iflist   = listsave;

    for( ; *(char *)iflist != 0; iflist++ )
    {
        // copy in the interface name to look up address of
        strncpy( ifreq.ifr_name, iflist->if_name, IF_NAMESIZE );

        // get the address for this interface
        if( ioctl( auxsock, SIOCGIFADDR, &ifreq ) < 0 )
        {
            // blank IP address
            if( errno != 99 )
            {
                Rioperror( "RioNeti_initialize: ioctl" );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - findNetInterface] Finish 2" << endl;
                #endif

                exit(1);
            }
        }

        // Take a valid address
        memset( &sa, 0, sizeof( struct sockaddr_in ) );
        memcpy( &sa, &ifreq.ifr_addr, sizeof( struct sockaddr_in ) );
        strcpy( localhost_ip, inet_ntoa( sa.sin_addr ) );

        #ifdef RIO_DEBUG2
        m_log << "RioNeti::findNetInterface endereco IP associado a placa: " 
              << localhost_ip << endl;
        #endif             

        if( strcmp( "127.0.0.1", localhost_ip ) != 0 )
            break; // Take the first ip different from 127.0.0.1
    }

    if_freenameindex( listsave );
    close( auxsock );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - findNetInterface] Finish 3" << endl;
    #endif

    return sa.sin_addr.s_addr;
}

int RioNeti::FreeBlock	(	unsigned int	block_id,
		RioStreamType	traffic
	)

FreeBlock recupera os fragmentos dispon�veis do bloco indicado pelo par�metro block_id para exibi��o imediata no cliente.

Liberado o bloco, a callback do cliente � chamada e o bloco � gravado no PlayOutBuffer para uso do player e, caso a op��o usecache esteja habilitada, o bloco � gravado na cache (no disco).

Parameters:

	block_id	� a identifica��o do bloco cujos fragmentos, caso existam, ser�o liberados.
	traffic	indica se o bloco a ser recuperado � relativo a um tr�fego multicast(traffic == MULTICASTTRAFFIC) ou unicast(traffic == UNICASTTRAFFIC).

Returns:

retorna o tamanho em bytes do bloco recuperado.

Definition at line 1034 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - FreeBlock] Start" << endl;
    #endif

    bool              status     = true;
    NetBuf           *rp         = NULL;
    int               n_frag     = 0;
    int               blocksize  = 0;
    int               totalfrags = 0;
    RioNetiReqIdItem *current    = NULL;
    RioNetiReqIdItem *previous   = NULL;

    #ifdef RIO_DEBUG2
    m_log << "[RioNeti] Entrei na FreeBlock..." << endl;
    #endif
    
    if( traffic == MULTICASTTRAFFIC )
    {
        HashMutexLock( "freeblck1" );
        int result = reqid_table->Search( (int) block_id, &current,
                                          &previous );

        if( result == RESULT_NETIREQT_SEARCH_FOUND )
        {
            #ifdef RIO_DEBUG2
            m_log << "[RioNeti] FreeBlock chamado para bloco " << block_id
                   << ", multicast de reqid " << current->GetLreqid() << endl;
            #endif

            rp = iHashFind( current->GetLreqid() );

            if( !rp )
            {
                status = false;

                #ifdef RIO_DEBUG2
                m_log << "[RioNeti] FreeBlock - Não foram encontrados "
                       << "fragmentos do bloco multicast "
                       << current->GetPreqid()
                       << ". O mesmo não existe na tabela hash." << endl;
                #endif
            }
            else
            {
                if( rp->rq_fraghigh == 0 )
                {
                    //Esta situacao nao deveria acontecer nunca pois o bloco
                    //multicast so eh inserido na tabela quando chega o seu
                    //fragmento zero e nao quando é requisitado (se for
                    //requisitado por este cliente quando ele for o líder
                    //do grupo).
                    status = false;

                    #ifdef RIO_DEBUG_EMUL
                    RioRequest *Request = ( RioRequest * ) rp->nb_userparm;
                    m_log << "[RioNeti] FreeBlock - Nao foram encontrados "
                           << "fragmentos do bloco multicast "
                           << current->GetPreqid() << " de reqid "
                           << current->GetLreqid() << " na cache. Mais alto de "
                           << "valor zero!" << endl;
                    char sent[256];
                    int numfrags;
                    numfrags = 1 + (( rp->nb_blockl - rp->rq_fraglen0 +  
                               rp->rq_fraglen - 1) / rp->rq_fraglen );
                    sprintf( sent, "= %d = %d = %u = %d%% perdido.", block_id, 
                             numfrags, Request->Block, 100 );
                    m_log << sent << endl;
                    #endif
                }

                reqid_table->Remove( current->GetPreqid() );
            }
        }
        else // else do if( result == RESULT_NETIREQT_SEARCH_FOUND )
        {
            status = false;

            #ifdef RIO_DEBUG2
            m_log << "[RioNeti] FreeBlock - Bloco multicast " << block_id
                   << " não existe na tabela multicast." << endl;
            #endif
        } // fim do else do if( result == RESULT_NETIREQT_SEARCH_FOUND )
    }
    else // else do if( traffic == MULTICASTTRAFFIC )
    {
        HashMutexLock( "freeblck2" );
        rp = iHashFind( block_id );
        if( !rp )
        {
            status = false;

            #ifdef RIO_DEBUG2
            m_log << "[RioNeti] FreeBlock - Não foram encontrados "
                   << "fragmentos do bloco unicast de reqid " << block_id
                   << ". O mesmo não existe na tabela hash." << endl;
            #endif
        }
        else if( rp->rq_fraghigh == 0 )
        {
            status = false;

            #ifdef RIO_DEBUG_EMUL
            RioRequest *Request = ( RioRequest * ) rp->nb_userparm;
            m_log << "[RioNeti] FreeBlock - Não foram encontrados "
                   << "fragmentos do bloco unicast de reqid " << block_id
                   << " na cache. Mais alto de valor zero!" << endl;
            char sent[256];
            int numfrags;
            numfrags = 1 + (( rp->nb_blockl - rp->rq_fraglen0 + 
                              rp->rq_fraglen - 1) / rp->rq_fraglen );
            sprintf( sent, "Lost fragments = %d = %d = %u = %d%% perdido.", 
                     block_id, numfrags, Request->Block, 100 );
            m_log << sent << endl;
            #endif
        }
    } // fim do else do if( traffic == MULTICASTTRAFFIC )

    if( status )
    {
        totalfrags = 1 + ((int) ( rp->nb_blockl/( m_maxpktl -
                                  (iphdrlen + udphdrlen) )));

        rp->rq_needack = -1000;
        cnt_rcvfragack++;

        #ifdef RIO_DEBUG_EMUL
        char sent[256];
        sprintf( sent, "[FreeBlock] Lost fragments: " );
        int lostfragments = 0;
        #endif

        // Search to check how many fragments arrived for this block
        for( int i = 0; i <= totalfrags - 1; i++ )
        {
            if( rp->rq_bits[i] == 1 )
            {
                n_frag++;
            }
            #ifdef RIO_DEBUG_EMUL
            else
            {
                sprintf( sent, "%d/", i );
                lostfragments++;
            }
            #endif
        }

        #ifdef RIO_DEBUG_EMUL
        int numfrags;
        RioRequest *Request = ( RioRequest * ) rp->nb_userparm;
        numfrags = 1 + (( rp->nb_blockl - rp->rq_fraglen0 + 
                          rp->rq_fraglen - 1) / rp->rq_fraglen );
        sprintf( sent, "Lost fragments = %d = %d = %u = %d%% perdido.", 
                 block_id, lostfragments, Request->Block, 
                 ( int )( 100*lostfragments/numfrags ) );
        m_log << sent << endl;
        #endif

        if( n_frag > 0 )
        {
            if( rp->rq_bits[ 0 ] == 1 )
            {
                blocksize += rp->rq_fraglen0;
                n_frag--;
            }
            if( rp->rq_bits[ totalfrags - 1 ] == 1 )
            {
                blocksize += ( rp->nb_blockl - ( rp->rq_fraglen0 +
                             ( ( totalfrags - 2 ) * rp->rq_fraglen ) ) );
                n_frag--;
            }
            blocksize += n_frag * rp->rq_fraglen;
            qComplete( rp, 0 );
        }
        #ifdef RIO_DEBUG2
        else
        {
            //Ao menos teoricamente nao eh pra a execucao passar nunca por
            //este ponto aqui.
            m_log << "[FreeBlock] Erro critico!!! Nao existe nenhum "
                   << "fragmento a ser recuperado para este bloco apesar do "
                   << "detectado acima!!!" << endl;
        }
        #endif
    } // fim do if( status )
    #ifdef RIO_DEBUG2
    else
    {
        m_log << "[RioNeti] FreeBlock não pôde recuperar bloco de reqid "
               << block_id << "." << endl;
    }

    m_log << "[RioNeti] FreeBlock recuperou " << blocksize << " bytes "<< endl;
    #endif

    HashMutexUnlock( "freeblck3" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - FreeBlock] Finish" << endl;
    #endif

    return blocksize;
}

int RioNeti::FreePendentBlocks	(	bool	useCache,
		int	nBuffers
	)

FreePendentBlocks procura por blocos que come�aram a ser recebidos h� bastante tempo mas que por perdas na rede n�o foram completamente recebidos.

Cada um destes blocos ser� liberado para uso independente do n�mero de fragmentos que tenham chegado. Isto � feito para diminuir o consumo de mem�ria. Em ambientes com muitas perdas e clientes altamente interativos muitos blocos ficam pendentes pois os clientes interagem antes de precisar deles e, portanto, n�o chamam a FreeBlock para tais blocos, que ficam ocupando a mem�ria eternamente por estarem na lista de requisi��es pendentes (tabela da NetBuf). Como os blocos com perdas nao sao gravados na cache, entao todos os blocos que a FreePendentBlocks encontrar como pendetes com tempo maximo de tolerancia excedido serao descartados.

Parameters:

	usecache	Informa se o cliente est� ou n�o usando cache em disco.
	nbuffers	Informa o tamanho do PlayOutBuffer do cliente.
	traffic	Informa se o bloco a ser recuperado � fruto de uma requisi��o unicast ou multicast. Esta ionforma��o � �til para a FreeBlock.

Returns:

Retorno o total de bytes liberados/recuperados/descartados por este m�todo.

Definition at line 1240 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - FreePendentBlocks] Start" << endl;
    #endif

    time_t            now        = time(NULL);
    int               totalFreed = 0;
    RioNetiReqIdItem *current    = NULL;
    RioNetiReqIdItem *previous   = NULL;
    NetBuf           *rp         = NULL;
    int               ix         = 0;
    NetBuf           *nbp        = NULL;
    NetBuf           *nbpNext    = NULL;

    //Imprimindo o conteudo da tabela Hash na tela antes e depois da varredura
    //por blocos pendentes e suas respectivas liberacoes. 
    #ifdef RIO_DEBUG2
    m_log << "Hora: " << now << endl;
    prtHash( "[FreePendentBlocks] Antes da varredura..." );
    #endif

    for( ix = 0; ix < XM_REQNUM; ix++ )
    {
        for( nbp = reqarray[ix]; nbp != NULL; nbp = nbpNext )
        {
            //E necessario armazenar o nb_link na linha abaixo pois
            //possivelmente nbp sera eliminado do sistema e poderemos perder o
            //ponteiro para o proximo NetBuf da tabela.
            nbpNext = nbp->nb_link;

            //temos que verificar se o NetBuf nao se refere a um bloco que
            //chegou entre a chamada a time(NULL) acima e este ponto no codigo,
            //por isso verificamos se now > nb_frag0arrive tambem.
            if( ( now > nbp->nb_frag0arrive ) &&
                ( ( now - nbp->nb_frag0arrive ) >= (time_t)( 5 * nBuffers ) )
              )
            {
                if( nbp->nb_unicastRequested )
                {
                    #ifdef RIO_DEBUG2
                    m_log << "[FreePendentBlocks] Liberando bloco unicast "
                           << "pendente de reqid " << nbp->nb_reqid
                           << " preso há " << now - nbp->nb_frag0arrive
                           << " segundos." << endl;
                    #endif
                }
                else
                {
                    #ifdef RIO_DEBUG2
                    m_log << "[FreePendentBlocks] Liberando bloco multicast "
                           << "pendente de reqid " << nbp->nb_reqid
                           << " preso há " << now - nbp->nb_frag0arrive
                           << " segundos." << endl;
                    #endif

                    //implementar um search que recebe o Lreqid e obtém o Preqid
                    int result = reqid_table->SearchL( nbp->nb_reqid, &current,
                                                       &previous );

                    if( result == RESULT_NETIREQT_SEARCH_FOUND )
                    {
                        rp = iHashFind( current->GetLreqid() );

                        if( rp )
                            reqid_table->Remove( current->GetPreqid() );
                    }
                }

                if( nbp->rq_fraghav == 0 )
                {
                    #ifdef RIO_DEBUG2
                    m_log << "[FreePendentBlocks] Bloco de reqid "
                           << nbp->nb_reqid << " estourou o tempo limite de "
                           << "chegada sem sequer receber seu fragmento zero. "
                           << "Removendo-o da Hash." << endl;
                    #endif


                    //Quando chama-se a FreeBlock para um bloco que tenha o
                    //fragmento zero, alguns metodos, dentro da FreeBlock ede
                    //metodos chamado por ela, sao executados. No caso de um
                    //bloco que nao tenha o fragmento zero temos que chamar
                    //cada um dos meodos que liberam este NetBuf do sistema. Os
                    //metodos em questão sao:iHashRmv, iOutRmv, iTimeR e
                    //mbfree, sendo que antes da chamada a mbfree o membro
                    //nb_link tem que ser setado para NULL (0). Fazemos isto
                    //manualmente abaixo jah que a FreeBlock nao executa tais
                    //procedimentos para blocos sem o fragmento zero.
                    HashMutexLock( "freependentblck1" );
                    iHashRmv( nbp );
                    iOutRmv( nbp );
                    iTimeRmv( nbp );
                    nbp->nb_link = 0;
                    mbfree( nbp );
                    HashMutexUnlock( "freependentblck1" );
                }
                else
                {
                    //Chamamos a FreeBlock aqui independente de o cliente usar
                    //cache ou não. Se o cliente usar cache então os blocos
                    //pendentes que forem liberados serão gravados na cache.
                    //Caso o cliente não use cache então estes blocos serão
                    //simplesmente descartados.
                    //Como removemos acima, caso o bloco fosse de uma
                    //requisicao multicast, o bloco da tabela de requisicoes
                    //multicast, entao chamaremos a FreeBlock com o segundo
                    //parametro igual a UNICASTTRAFFIC independente do seu
                    //tipo(isto soh eh usado na FreeBlock para remover o bloco
                    //da tabela multicast.
                    totalFreed += FreeBlock( nbp->nb_reqid, UNICASTTRAFFIC );
                }
            }
            else
            {
                continue;
            }
        }
    }

    #ifdef RIO_DEBUG2
    prtHash( "[FreePendentBlocks] Depois da varredura." );
    #endif

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - FreePendentBlocks] Finish" << endl;
    #endif

    return totalFreed;
}

void RioNeti::fSend

(

NetBuf *

nbp

)

[static, private]

Definition at line 3119 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - fSend] Start" << endl;
    #endif

    RioNeti *netiPtr = nbp->nb_rioneti;

    if( netiPtr->writefdsp || netiPtr->iSend(nbp) )
    { // writes being delayed
        netiPtr->iOutAdd( nbp, &fSend );
    }
    else
    {
        netiPtr->mbfree( nbp );
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - fSend] Finish" << endl;
    #endif
}

void RioNeti::getalladdrport	(	int **	ipaddr,
		int **	port
	)

Definition at line 1722 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - getalladdrport] Start" << endl;
    #endif

    // Esta funcao retorna o vetor de mapeamentos (IP, porta) utilizados pelo
    // cliente. Se o cliente nao estiver atras de um NAT, todos os valores
    // serao iguais ao par (m_ipaddr, m_ipport). O primeiro mapeamento e
    // utilizado na comunicacao com o servidor, e os demais, para os storages.

    *ipaddr = m_ipaddrmap;
    *port   = m_ipportmap;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - getalladdrport] Finish" << endl;
    #endif
}

int RioNeti::getipaddr

(

)

Definition at line 1743 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - getipaddr] Single" << endl;
    #endif

    // Esta funcao agora retorna o endereco IP determinado pela chamada a
    // funcao RequestMapping. Se nao usarmos esta funcao ou se o cliente nao
    // estiver atras de um NAT, este valor sera igual a m_ipaddr.
    return( m_ipaddrmap[0] );
}

void RioNeti::getmyaddrport	(	int *	ipaddr,
		int *	port,
		int	server = 0
	)

Definition at line 1698 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - getmyaddrport] Start" << endl;
    #endif

    // Esta funcao agora retorna o endereco IP e a porta determinados pela 
    // chamada a funcao RequestMapping. Se nao usarmos esta funcao ou se o
    // cliente nao estiver atras de um NAT, estes valores serao iguais, 
    // respectivamente, aos valores de m_ipaddr e de m_ipport.
    // Para o servidor e para cada storage, há um mapeamento diferente. O
    // parâmetro server indica qual mapeamento deve ser retornado - 0 para o
    // mapeamento do servidor e 1, 2, .... para cada storage

    *ipaddr = m_ipaddrmap[server];
    *port   = m_ipportmap[server];

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - getmyaddrport] Finish" << endl;
    #endif
}

void RioNeti::gSend

(

NetBuf *

nbp

)

[static, private]

Definition at line 3096 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - gSend] Start" << endl;
    #endif

    RioNeti *netiPtr = nbp->nb_rioneti;

    if( netiPtr->writefdsp || netiPtr->iSend(nbp) )
    {
        // writes being delayed
        netiPtr->iOutAdd( nbp, &gSend );
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - gSend] Finish" << endl;
    #endif
}

void RioNeti::HashMutexLock

(

string

msg = ""

)

[private]

Definition at line 5732 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG2
    if( msg.length() )
        m_log << "[HashMutexLock] " << msg << "... " << endl;
    #endif

    #ifdef WINDOWS
    /* Windows implementation */
    WaitForSingleObject( HashMutex,INFINITE ); };
    #else
    /* Linux implementation */
    pthread_mutex_lock( &HashMutex );
    #endif

    #ifdef RIO_DEBUG2
    if( msg.length() )
        m_log << "..." << msg << " OK!" << endl;
    #endif
}

void RioNeti::HashMutexUnlock

(

string

msg = ""

)

[private]

Definition at line 5753 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG2
    if( msg.length() )
        m_log << "[HashMutexUnlock] " << msg << endl;
    #endif

    #ifdef WINDOWS
    /* Windows implementation */
    ReleaseMutex( HashMutex ); };
    #else
    /* Linux implementation */
    pthread_mutex_unlock( &HashMutex );
    #endif
}

NetBuf * RioNeti::iHashFind

(

int

reqid

)

[private]

Definition at line 2528 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashFind] Start" << endl;
    #endif

    int ix = XM_REQMASK & reqid;

    for(NetBuf *nbp = reqarray[ix]; nbp != 0; nbp = nbp->nb_link)
    {
        if( nbp->nb_reqid == reqid )
        {
            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - iHashFind] Finish 1" << endl;
            #endif

            return nbp;
        }
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashFind] Finish 2" << endl;
    #endif

    return 0;
}

NetBuf * RioNeti::iHashFindRst	(	int	ip,
		int	port,
		int	reqid
	)			[private]

Definition at line 2560 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashFindRst] Start" << endl;
    #endif

    if( m_debug & DEBUG_DATA )
    {
        char print[256];
        sprintf(print, " iHashFindRst %8.8x %8.8x %8.8x" ,
                (unsigned)ip, (unsigned)port, (unsigned)reqid);
        m_log << print << endl;
    }
    for( int i = 0; i < XM_REQNUM; i++ )
    {
        for( NetBuf *nbp = reqarray[i]; nbp != 0; nbp = nbp->nb_link)
        {
            if( m_debug & DEBUG_DATA )
            {
                char print[256];
                sprintf(print, " \t%d-\t%p %8.8x %8.8x %8.8x" ,
                        i, nbp, (unsigned)nbp->nb_toipaddr,
                        (unsigned)nbp->nb_toipport,
                        (unsigned)nbp->nb_hisreqid );
                m_log << print << endl;
            }
            if( (nbp->nb_hisreqid == reqid ) && ( nbp->nb_toipport == port )
                && ( nbp->nb_toipaddr == ip ))
            {
                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - iHashFindRst] Finish 1" << endl;
                #endif

                return nbp;
            }
        }
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashFindRst] Finish 2" << endl;
    #endif

    return 0;
}

void RioNeti::iHashNew

(

NetBuf *

nbp

)

[private]

Definition at line 2431 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashNew] Start" << endl;
    #endif

    #ifdef RIO_DEBUG2
    if( rp->nb_unicastRequested )
        m_log << "[RioNeti] iHashNew - Adicionando bloco unicast de reqid "
               << rp->nb_reqid << " da tabela Hash." << endl;
    else
        m_log << "[RioNeti] iHashNew - Adicionando bloco multicast de reqid "
               << rp->nb_reqid << " da tabela Hash." << endl;
    #endif

    rp->nb_hisreqid = 0;    // be sure iHashFindRst can't find this (yet)
retry:
    rp->nb_reqid = ++reqseq;

    if( rp->nb_reqid == 0 )
        goto retry;    // skip reqid 0
    if( m_debug & DEBUG_DATA )
    {
        m_log << " iHashNew reqid " << rp->nb_reqid << endl;
    }
    int ix = XM_REQMASK & rp->nb_reqid;
    rp->nb_link = reqarray[ix];
    reqarray[ix] = rp;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashNew] Finish" << endl;
    #endif
}

void RioNeti::iHashRmv

(

NetBuf *

nbp

)

[private]

Definition at line 2468 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashRmv] Start" << endl;
    #endif
    
    #ifdef RIO_DEBUG2
    if( rp->nb_unicastRequested )
        m_log << "[RioNeti] iHashRmv - Removendo bloco unicast de reqid "
               << rp->nb_reqid << " da tabela Hash." << endl;
    else
        m_log << "[RioNeti] iHashRmv - Removendo bloco multicast de reqid "
               << rp->nb_reqid << " da tabela Hash." << endl;
    #endif

    NetBuf *p0, *p1;
    int ix;

    if( m_debug & DEBUG_DATA )
    {
        m_log << " iHashRmv reqid " << rp->nb_reqid << endl;
    }
    ix = XM_REQMASK & rp->nb_reqid;

    // find this pending request in reqarray hash table

    p0 = VIRTORG(reqarray[ix], NetBuf, nb_link);

    for( p1 = p0->nb_link; p1 != NULL; p0 = p1, p1 = p0->nb_link)
    {
        if( p1 != rp ) continue;
        // found it, p0 = @ previous element
        p0->nb_link = rp->nb_link; // remove from hash chain

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iHashRmv] Finish 1" << endl;
        #endif

        return;
    }

    // not found on hash list
    #ifdef RIO_DEBUG2
    char print[256];
    sprintf(print, " iHashRmv - reqid %d not found [%px]" ,
            rp->nb_reqid, rp);
    m_log << print << endl;
    m_log << "RioNeti- chamando raise " << endl;
    #endif
    
    raise( SIGFPE ); // FPE = Float Point Exception

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iHashRmv] Finish 2" << endl;
    #endif
}

int RioNeti::InsertMulticastReqid	(	int	multicastreqid,
		int	localreqid
	)			[private]

void RioNeti::iOutAdd	(	NetBuf *	nbp,
		void(*)(NetBuf *)	outrtn
	)			[private]

Definition at line 1779 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iOutAdd] Start" << endl;
    #endif

    if( nbp->nb_outrtn )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iOutAdd] Finish 1" << endl;
        #endif

        return;    // return if already on queue
    }

    nbp->nb_outrtn = outrtn;

    nbp->nb_outnext = 0;
    m_outql->nb_outnext = nbp;
    m_outql = nbp;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iOutAdd] Finish 2" << endl;
    #endif
}

void RioNeti::iOutAddTop	(	NetBuf *	nbp,
		void(*)(NetBuf *)	outrtn
	)			[private]

Definition at line 1813 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iOutAddTop] Start" << endl;
    #endif

    if( nbp->nb_outrtn )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iOutAddTop] Finish 1" << endl;
        #endif

        return;    // return if already on queue
    }

    nbp->nb_outrtn = outrtn;

    nbp->nb_outnext = m_outqf;

    if( !m_outqf )
    {
        m_outql = nbp;
    }

    m_outqf = nbp;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iOutAddTop] Finish 2" << endl;
    #endif
}

void RioNeti::iOutRmv

(

NetBuf *

nbp

)

[private]

Definition at line 1848 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iOutRmv] Start" << endl;
    #endif

    NetBuf *p0, *p1;

    if( !nbp->nb_outrtn )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iOutRmv] Finish 1" << endl;
        #endif

        return;    // return if not on queue
    }

    p0 = VIRTORG(m_outqf, NetBuf, nb_outnext);
    for( p1 = p0->nb_outnext; p1 != NULL; p0 = p1, p1 = p0->nb_outnext)
    {
        if( p1 != nbp )
            continue;
        // found it, p0 = @ previous element
        p0->nb_outnext = nbp->nb_outnext; // remove from hash chain
        if( m_outql == nbp )
        {
            m_outql = p0;        // was last, fix last ptr too
        }
        nbp->nb_outrtn = 0;        // not on out queue

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iOutRmv] Finish 2" << endl;
        #endif

        return;
    }
}

int RioNeti::iRetry

(

NetBuf *

nbp

)

[private]

Definition at line 3173 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iRetry] Start" << endl;
    #endif

    if( nbp->rq_retry <= 0 )
    {
        #ifdef RIO_DEBUG2
        m_log << "iRetry nbp->nb_result " << nbp->nb_result << endl;
        #endif

        qComplete(nbp, ERROR_RIONETI+0xe0);    // retry failed
        if( m_debug & (1 << 9) )
        {
            abort();
        }

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iRetry] Finish 1" << endl;
        #endif

        return 0;
    }

    nbp->rq_retry--;
    cnt_retry++;

    #ifdef RIO_DEBUG2
    m_log << "iRetry tentanto enviar novamente o pacote. Restam " 
          << nbp->rq_retry << " tentativas adiconais. Foram feitas, ate o "
          << "momento " << cnt_retry << " tentativas de reenvio no total "
          << "(para todos os fragmentos enviados pelo servidor)" << endl;
    #endif

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iRetry] Finish 2" << endl;
    #endif

    return 1;
}

bool RioNeti::IsBehindNAT

(

)

IsBehindNAT esta funcao retorna true se o cliente estiver atras de um NAT, caso a funcao RequestMapping tenha sido chamada pelo cliente para obter o mapeamento, e false caso o cliente nao esteja atras do NAT ou se a funcao RequestMapping nao tenha sido chamada.

Returns:

true se o cliente esta atras de NAT, ou false se ele nao esta atras de NAT ou se a funcao RequestMapping nao foi chamada.

Definition at line 5963 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - IsBehindNAT] Single" << endl;
    #endif

    return( m_behindnat );
}

int RioNeti::iSend

(

NetBuf *

nbp

)

[private]

iSend funcao para enviar um objeto NetBuf pela rede.

Se o trafego ao qual o objeto NetBuf pertence for de tempo real, e se foi definido um objeto para controlar o fluxo de saida de objetos NetBuf, o objeto sera repassado para o objeto m_StreamControl que controla o controle de fluxo. O objeto, neste caso, sera enviado (via funcao scSend) respeitando-se o limite de trafego do cliente e do servidor. Em caso contrario, a funcao nbSend (a antiga funcao iSend) e chamada para enviar imediatamente o objeto NetBuf.

Parameters:

nbp

ponteiro para o objeto NetBuf a ser enviado.

Returns:

valor diferente de 0: ocorreu um erro ao enviar o objeto NetBuf.

Definition at line 2983 of file RioNeti.cpp.

{
    int result;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSend] Start" << endl;
    #endif

    #ifdef RIO_DEBUG2
    m_log << "RioNeti::iSend - sending a packet of type "
          << (int)((RioPkt::pktp *) nbp->nb_bufp)->type << endl;
    #endif

    if( ( nbp->nb_sendack != 0 ) ||
        ( (int)((RioPkt::pktp *) nbp->nb_bufp)->type != TYPE_FRAG ) ||
        ( m_StreamControl == NULL ) )
    {
        #ifdef RIO_DEBUG2
        m_log << "RioNeti::iSend usando a funcao nbsend, nb_sendack=" 
               << nbp->nb_sendack << endl;
        #endif       

        result = nbSend( nbp );
    }
    else
    {
        #ifdef RIO_DEBUG2
        m_log << "RioNeti::iSend usando a funcao Put, nbp = " << nbp 
              << ", nbp->nb_sendack=" << nbp->nb_sendack 
              << ", nbp->rq_fragmax = " << nbp->rq_fragmax 
              << ", nbp->rq_fragsh = " << nbp->rq_fragsh << endl;
        #endif       
        result = m_StreamControl->Put( nbp ); // Devemos ignorar o resultado?
    }

    #ifdef RIO_DEBUG2
    m_log << "RioNeti::iSend result = " << result << endl;
    #endif       

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSend] Finish" << endl;
    #endif

    return result;
}

void RioNeti::iSendAck	(	int	ipaddr,
		int	port,
		int	reqid
	)			[private]

Definition at line 3545 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendAck] Start" << endl;
    #endif

    NetBuf *nbp;
    RioPkt::pktp *p;

    if( m_debug & DEBUG_CMDS)
    {
        char print[256];
        sprintf( print, " SendAck: %8.8x %8.8x %8.8x" ,
                 (unsigned)ipaddr, (unsigned)port, (unsigned)reqid );
        m_log << print << endl;
    }

    nbp              = mbget();
    nbp->nb_toipaddr = ipaddr;
    nbp->nb_toipport = port;
    nbp->nb_sendp    = nbp->nb_buf;
    p                = (RioPkt::pktp *) nbp->nb_sendp;
    p->type          = TYPE_ACK;
    p->x1            = 0;
    p->x2            = 0;
    p->reqid         = reqid;
    nbp->nb_sendl    = sizeof( RioPkt::pktp );
    p->auth.makeauth( nbp->nb_sendp, nbp->nb_sendl, nbp );
    fSend( nbp );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendAck] Finish" << endl;
    #endif
}

void RioNeti::iSendFrag

(

NetBuf *

nbp

)

[static, private]

Definition at line 3218 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFrag] Start" << endl;
    #endif
    
    RioNeti *netiPtr = nbp->nb_rioneti;

    do
    {
        /*
         * Since the sendto system call silently drop the packets whenever the
         * output queue is full, this piece of code give its enough time to
         * empty the queue. The sleep value is get from empirical experiments
         * and take into account the network bandwidth.
         */
        if( netiPtr->writefdsp || netiPtr->iSend( nbp ) )
        {
            if( nbp->nb_sendack != 0 )
            {
                netiPtr->iOutAdd(nbp, &iSendFrag);
            }
            // if sys output queue is full, don't push so hard
            // so that other send requests can send some pkts too

            if( nbp->rq_fragburst > NetBuf::RQ_BURSTMAX )
            {
                nbp->rq_fragburst = NetBuf::RQ_BURSTMAX;

                if( nbp->rq_burstcnt > nbp->rq_fragburst )
                {
                    nbp->rq_burstcnt = nbp->rq_fragburst;
                }
            }

            #ifdef RIO_DEBUG2
            m_log << "iSendFrag reqid " << nbp->nb_reqid
                   << " fragburst = "<< nbp->rq_fragburst
                   << " burst = "<< nbp->rq_burstcnt <<endl;
            #endif

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - iSendFrag] Finish 1" << endl;
            #endif

            return;
        }
    } while(!netiPtr->iSendFragNext(nbp));

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFrag] Finish 2" << endl;
    #endif
}

void RioNeti::iSendFragAck

(

NetBuf *

nbp

)

[static, private]

Definition at line 3461 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFragAck] Start" << endl;
    #endif

    RioNeti *netiPtr = nbp->nb_rioneti;

    // can't send if haven't received frag 0 yet
    if( !nbp->rq_bits[0] )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iSendFragAck] Finish 1" << endl;
        #endif

        return;
    }

    nbp->nb_sendp = nbp->nb_bufp;

    RioPkt::pktfa *p = (RioPkt::pktfa *) nbp->nb_sendp;
    p->type = TYPE_FRAGACK;
    p->x1 = 0;
    p->fragackseq = htons(++nbp->rq_fragackseq);
    p->reqid = nbp->nb_hisreqid;
    p->fragnum = htons(nbp->rq_fraghav);
    p->fraghigh = htons(nbp->rq_fraghigh);

    #ifdef RIO_DEBUG2
    m_log << " isendfragack reqid " << nbp->nb_reqid
          << " ackseq "  << nbp->rq_fragackseq
          << " fragnum " << nbp->rq_fraghav
          << " high " << nbp->rq_fraghigh << endl;
    #endif

    u16 *pl = (u16 *) (nbp->nb_sendp + sizeof(RioPkt::pktfa));
    int i = NetBuf::RQ_MAXACKLIST;
    for(u16 x = nbp->rq_fraglow+1; x < nbp->rq_fraghigh; x++)
    {
        if( !nbp->rq_bits[x] )
        {
            if( i-- > 0 )
                *pl++ = htons(x);
            else break;
        }
    }

    nbp->nb_sendl = ((char *) pl) - nbp->nb_sendp;
    p->auth.makeauth(nbp->nb_sendp, nbp->nb_sendl, nbp);

    if( netiPtr->iSend(nbp) )
    {
        netiPtr->iOutAddTop(nbp, &iSendFragAck);

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iSendFragAck] Finish 2" << endl;
        #endif

        return;
    }
    else
    {
        if( nbp->rq_needack <= -1000 )
        {
            // is complete, was final ack
            netiPtr->qComplete(nbp, 0);

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - iSendFragAck] Finish 3" << endl;
            #endif

            return;
        }
    }
    nbp->rq_needack = NetBuf::RQ_ACKEVERY;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFragAck] Finish 4" << endl;
    #endif

}

void RioNeti::iSendFragBuild	(	NetBuf *	nbp,
		int	fragnum
	)			[private]

Definition at line 3276 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFragBuild] Start" << endl;
    #endif

    char *dp, *pp;
    int dl;

    int maxsize = 0;

    nbp->rq_bits[fragnum] = nbp->rq_fragackseq; // remember when sent
    pp = nbp->nb_bufp;
    nbp->nb_sendp = pp;

    RioPkt::pktf0 *p = (RioPkt::pktf0 *) pp;
        p->pfx.type = TYPE_FRAG;
        p->pfx.x1 = 0;
        p->pfx.fragnum = htons(fragnum);
        p->pfx.reqid = nbp->nb_hisreqid;

    if( fragnum == 0 )
    {
        dp = nbp->nb_blockp;
        dl = nbp->rq_fraglen0;
        p->ackreqid = nbp->nb_reqid;
        p->fragmax = htons(nbp->rq_fragmax);
        p->maxpktl = htons(nbp->rq_maxpktl);
        p->auth.makeauth(nbp->nb_blockp, nbp->nb_blockl, nbp);
        pp += sizeof(RioPkt::pktf0);
        maxsize = maxsize + sizeof(RioPkt::pktf0);
    }
    else
    {
        dp = nbp->nb_blockp +
            nbp->rq_fraglen0 + (fragnum-1)*(nbp->rq_fraglen);
        dl = nbp->rq_fraglen;
        pp += sizeof(RioPkt::pktfx);
        maxsize = maxsize + sizeof(RioPkt::pktfx);
    }

    if( dp+dl > nbp->nb_blockp+nbp->nb_blockl)
    {
        dl = nbp->nb_blockp+nbp->nb_blockl - dp;
        if( dl <= 0)
        {    // only happens on bad frag number
            dl = 0;
        }
    }

    maxsize = maxsize + dl;

    if( maxsize > FRAGMENTSIZE )
        RioErr << "RioNeti::iSendFragBuild maxsize = " << maxsize << " > " 
               << FRAGMENTSIZE << endl;

    memcpy(pp, dp, dl);
    nbp->nb_sendl = pp + dl - nbp->nb_sendp;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFragBuild] Finish" << endl;
    #endif
}

int RioNeti::iSendFragNext

(

NetBuf *

nbp

)

[private]

Definition at line 3348 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFragNext] Start" << endl;
    #endif

    int i, frag;

    if( m_debug & DEBUG_FRAG)
    {
        m_log << " iSendFragNext - rq_burstcnt " << nbp->rq_burstcnt
              << "  rq_fraglistn " << nbp->rq_fraglistn << "  rq_fragackseq "
              << nbp->rq_fragackseq << endl;
        m_log << "  rq_fraglist: ";
        for(i = 0; i < NetBuf::RQ_MAXACKLIST; i++)
        {
            m_log << "  " << nbp->rq_fraglist[i] << " ["
                  << nbp->rq_bits[nbp->rq_fraglist[i]] << "]";
        }
        m_log << " " << endl;
    }

    if( nbp->nb_sendack != 0 )
    {
        if( !nbp->rq_burstcnt)
        {
            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - iSendFragNext] Finish 1" << endl;
            #endif

            return 1;
        }

        // first try sending fragments reported missing
        // (but only if not sent for a while)
        for(i = 0; i < nbp->rq_fraglistn; i++)
        {
            frag = nbp->rq_fraglist[i];
            if( nbp->rq_fragackseq - nbp->rq_bits[frag] > 6)
            {
                nbp->rq_burstcnt--;
                iSendFragBuild(nbp, frag);

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - iSendFragNext] Finish 2" << endl;
                #endif

                return 0;
            }
        }
    }

    // try sending next fragment in main sequence
    if( nbp->rq_fragsh < nbp->rq_fragmax )
    {
        nbp->rq_burstcnt--;
        iSendFragBuild(nbp, nbp->rq_fragsh++);

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - iSendFragNext] Finish 3" << endl;
        #endif

        return 0;
    }

    if( nbp->nb_sendack != 0 )
    {
        // try sending missing which haven't just been sent
        // (also shrink burst count so don't send lots of extra fragments)
        if( nbp->rq_burstcnt > 3) nbp->rq_burstcnt = 3;
        for(i = 0; i < nbp->rq_fraglistn; i++)
        {
            frag = nbp->rq_fraglist[i];
            if( nbp->rq_fragackseq - nbp->rq_bits[frag] > 0 )
            {
                nbp->rq_burstcnt--;
                iSendFragBuild(nbp, frag);

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - iSendFragNext] Finish 4" << endl;
                #endif

                return 0;
            }
        }
        // if any are currently reported missing send one frag
        // to elicit fragack on rtt later.  Without this dropped fragments
        // near the end of the block never get sent.
        if( nbp->rq_fraglistn )
        {
            nbp->rq_burstcnt = 0;        // only send one
            iSendFragBuild(nbp, nbp->rq_fraglist[0]);

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - iSendFragNext] Finish 5" << endl;
            #endif
 
            return 0;
        }
    }
    // nothing to send

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendFragNext] Finish 6" << endl;
    #endif

    return 1;
}

void RioNeti::iSendMapAck	(	int	ipaddr,
		int	port,
		int	reqid
	)			[private]

iSendMapAck Envia um ACK de uma requisicao por mapeamento para o IP ipaddr e a porta port.

Nota: esta funcao foi baseada no codigo da funcao iSendAck.

Parameters:

	ipaddr	endereco IP do objeto RioNeti para o qual desejamos enviar o ACK.
	port	porta do objeto RioNeti para o qual desejamos enviar o ACK.
	reqid	identificador para a requisicao (como devemos inicializar

Definition at line 6021 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendMapAck] Start" << endl;
    #endif

    NetBuf *nbp;
    RioPkt::pktpmap *p;

    if( m_debug & DEBUG_CMDS)
    {
        char print[256];
        sprintf( print, " SendMapAck: %8.8x %8.8x %8.8x" ,
                 (unsigned)ipaddr, (unsigned)port, (unsigned)reqid);
        m_log << print << endl;
    }

    nbp              = mbget();
    
    nbp->nb_toipaddr = ipaddr;
    nbp->nb_toipport = port;
    nbp->nb_sendp    = nbp->nb_buf;
    // Aqui, ao contrario da funcao iSendAck, usamos o novo tipo de pacote
    // RioPkt::pktpmap, que possui campos para armazenarmos um IP e a porta,
    // no caso, o IP e a porta do mapeamento. O tipo do ACK tambem agora e
    // o TYPE_MAPACK.
    p                = (RioPkt::pktpmap *) nbp->nb_sendp;
    p->type          = TYPE_MAPACK;
    p->IP            = ipaddr;
    p->port          = port;
    p->reqid         = reqid;
    nbp->nb_sendl    = sizeof( RioPkt::pktpmap );
    p->auth.makeauth( nbp->nb_sendp, nbp->nb_sendl, nbp );
    fSend( nbp );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iSendMapAck] Finish" << endl;
    #endif
}

void RioNeti::iTimeNew	(	NetBuf *	nbp,
		int	interval
	)			[private]

Definition at line 2608 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iTimeNew] Start" << endl;
    #endif

    NetBuf *p1, *p2, *p3;

    // first get fresh time as might not be on RioNeti thread
    // and now could be very very old...

    #ifdef WINDOWS
    // Windows implementation
    GetSystemTime(&pSystemTime);
    xm_now.tv_sec = pSystemTime.wSecond;
    xm_now.tv_usec = pSystemTime.wMilliseconds;
    #else
    // Linux implementation
    gettimeofday(&xm_now, NULL);
    #endif

    DQUEUE_RMV(nbp, nb_tidq);

    nbp->nb_tiwhen.tv_sec = xm_now.tv_sec + (interval >> TimeShift);
    nbp->nb_tiwhen.tv_usec = xm_now.tv_usec
            + ((interval & ((1 << TimeShift) - 1)) << (USECBITS-TimeShift));
    if( nbp->nb_tiwhen.tv_usec > USEC )
    {
        nbp->nb_tiwhen.tv_usec -= USEC;
        nbp->nb_tiwhen.tv_sec++;
    }

    #ifdef RIO_DEBUG2
    m_log << " iTimeNew " << nbp->nb_tiwhen.tv_sec << " "
          << nbp->nb_tiwhen.tv_usec << " " << interval << endl;
    #endif

    /* queue on time queue in order by time */
    p1 = VIRTORG( xm_timeq, NetBuf, nb_tidq );

    for( p2 = p1->nb_tidq.linkf; p2 != p1; p2 = p2->nb_tidq.linkf )
    {
        if( ( nbp->nb_tiwhen.tv_usec < p2->nb_tiwhen.tv_usec )
        && ( nbp->nb_tiwhen.tv_sec == p2->nb_tiwhen.tv_sec ))
                break;
        if( nbp->nb_tiwhen.tv_sec < p2->nb_tiwhen.tv_sec )
                break;

        // added to get error at the list
        if( p2 == p2->nb_tidq.linkf )
        {
            m_log << " Thread " << pthread_self()
                   <<  " Error at the xm_timeq list"  << endl;
            p2->nb_tidq.linkf = p1;
        }
    }

    p3 = p2->nb_tidq.linkb;

    DQUEUE_ADD(nbp, p3, nb_tidq);

    #ifdef DEBUGTIM
    prttim(" after iTimeNew" );
    #endif

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iTimeNew] Finish" << endl;
    #endif
}

void RioNeti::iTimeRmv

(

NetBuf *

nbp

)

[private]

Definition at line 2683 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iTimeRmv] Start" << endl;
    #endif

    DQUEUE_RMV(nbp, nb_tidq);
    nbp->nb_tidq.linkf = nbp->nb_tidq.linkb = nbp;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - iTimeRmv] Finish" << endl;
    #endif
}

void RioNeti::JoinGroup	(	int	sockIndex,
		char *	group_addr
	)			[private]

JoinGroup envia uma mensagem pra rede (roteadores) informando que o socket multicast de �ndice sockIndex deseja entrar no grupo multicast indicado em multicastInfo[sockIndex].myaddr_in.

Nota: Este m�todo n�o precisa usar SocketMulticastLock() nem SocketMulticastUnlock() pois est� sendo chamado pela SetMulticastSocket() que j� faz as respectivas chamadas.

Parameters:

	sockIndex	indice que indica a posicao do socket no vetor multicastInfo a ser manipulado.
	group_addr	endere�o no grupo a que este socket deve se unir.

Definition at line 1471 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - JoinGroup] Start" << endl;
    #endif

   #ifdef RIO_DEBUG2
   m_log << "Joining Group" << endl;
   #endif

   struct ip_mreq mreq;

   if( ( multicastInfo[sockIndex].myaddr_in.sin_addr.s_addr =
       inet_addr(group_addr)) == (unsigned) -1 )
   {
       m_log << " JoinGroup Error: inet_addr " << endl;
   }

   mreq.imr_multiaddr        = multicastInfo[sockIndex].myaddr_in.sin_addr;
   mreq.imr_interface.s_addr = INADDR_ANY;

   if( setsockopt( multicastInfo[sockIndex].socket, IPPROTO_IP,
                   IP_ADD_MEMBERSHIP, (char*) &mreq, sizeof(mreq)) == -1 )
   {
        Rioperror( "[RioNeti] JoinGroup error on ADD_MEMBERSHIP" );
   }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - JoinGroup] Finish" << endl;
    #endif
}

void * RioNeti::KeepaliveMapNAT

(

void *

Param

)

[static, private]

KeepaliveMapNAT funcao para a thread usada para enviar periodicamente mensagens Fake aos servidores para garantir que os mapeamentos nao serao expirados.

Parameters:

Param

o parametro da thread que e um ponteiro para um objeto da classe RioNeti executando o codigo da thread.

Definition at line 5807 of file RioNeti.cpp.

{
    RioNeti *PRioNeti;
    struct sockaddr_in Server;
    // A mensagem Fake e composta por um unico caractere, para minimizar o
    // uso dos recursos da rede.
    const char *FakeMsg = "f";
    int FakeMsgSize = 1;
    unsigned int i;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - KeepaliveMapNAT] Start" << endl;
    #endif

#ifdef RIO_DEBUG2
    struct in_addr ip;
#endif
    PRioNeti = (RioNeti *) Param;
    // Verifica se o vetor com os enderecos dos servidores foi inicializado.
    if( ( PRioNeti->m_MappingInfo == NULL ) || 
        ( PRioNeti->m_MappingInfoSize == 0 ) )
    {
        // Se o vetor nao foi inicializado, devemos gerar um erro.
        m_log << "RioNeti::KeepaliveMapNAT Erro interno na thread " 
               << (int)PRioNeti->m_threadmap << ": m_MappingInfo = " << hex 
               << PRioNeti->m_MappingInfo << dec 
               << ", m_MappingInfoSize = " << PRioNeti->m_MappingInfoSize 
               << endl;

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - KeepaliveMapNAT] Finish1" << endl;
        #endif

        pthread_exit( NULL );
    } 
    else 
    {
        // Se o vetor foi inicializado, devemos entrar em um laco infinito
        // para continuamente enviar as mensagens Fake que garantirao que os
        // mapeamentos continuarao validos.
        while( 1 ) 
        {
          // Envia uma mensagem Fake para cada servidor do vetor 
          // m_MappingInfo.
          for( i = 0; i <  PRioNeti->m_MappingInfoSize; i++ )
          {
              // Somente envia a mensagem se o servidor estiver habilitado.
              if( PRioNeti->m_MappingInfo[ i ].IsEnabled )
              {
                  #ifdef RIO_DEBUG2
                  ip.s_addr = PRioNeti->m_MappingInfo[ i ].IP;
                  m_log << "KeepaliveMapNAT - Sending FAKE message to "
                        << inet_ntoa( ip )<< ":" 
                        << ntohs(PRioNeti->m_MappingInfo[ i ].port) << "("
                        << i << "/" << PRioNeti->m_MappingInfoSize << ")" 
                        << endl;
                  #endif
                  Server.sin_family = AF_INET;
                  Server.sin_port = PRioNeti->m_MappingInfo[ i ].port;
                  Server.sin_addr.s_addr = PRioNeti->m_MappingInfo[ i ].IP;
                  sendto( PRioNeti->m_sock, FakeMsg, FakeMsgSize, 0,
                          (const struct sockaddr *)&Server, sizeof( Server ) );
              }
          }
          // Espera por FAKEMSGINTERVAL segundos antes de enviar novamente as
          // mensagens Fake. Assim como o tamanho da mensagem de um caractere,
          // isso tambem e para minimizar o uso dos recursos da rede.
          usleep( FAKEMSGINTERVAL );            
        }
    } 


    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - KeepaliveMapNAT] Finish2" << endl;
    #endif

    return NULL;
}

void RioNeti::LeaveAllGroups

(

void

)

Definition at line 1582 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - LeaveAllGroups] Start" << endl;
    #endif

    int sockIndex;

    for( sockIndex = 0; sockIndex < MULTICAST_SOCKETS; sockIndex++ )
    {
        if( multicastInfo[sockIndex].isConnected )
        {
            #ifdef RIO_DEBUG2
            m_log << "LeaveAllGroups chamando LeaveGroup para grupo "
                   << ntohs( multicastInfo[sockIndex].myaddr_in.sin_port )
                   << endl;
            #endif

            LeaveGroup( ntohs( multicastInfo[sockIndex].myaddr_in.sin_port ) );
        }
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - LeaveAllGroups] Finish 1" << endl;
    #endif
}

void RioNeti::LeaveGroup

(

unsigned short

multicastport

)

LeaveGroup descobre a qual membro da matriz multicastInfo o par�metro multicastport est� associado e fecha o socket respectivo, limpando os demais membros desta estrutura.

Definition at line 1503 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - LeaveGroup] Start" << endl;
    #endif

    int rc;
    int sockIndex;

    SocketMulticastLock( "leavelk" );

    #ifdef RIO_DEBUG2
    m_log << "[LeaveGroup] Leaving Group " << multicastport << "("
           << htons(multicastport) << ")"<< endl;
    #endif

    for( sockIndex = 0; sockIndex < MULTICAST_SOCKETS; sockIndex++ )
    {
        if( multicastInfo[sockIndex].myaddr_in.sin_port ==
            htons( multicastport )
          )
            break;
    }

    if( sockIndex == MULTICAST_SOCKETS )
    {
        #ifdef RIO_DEBUG2
        m_log << "[RioNeti] LeaveGroup ERROR: porta " << multicastport
               << " não encontrada. O socket multicast respectivo não poderá "
               << "ser fechado." << endl;

        m_log << "[RioNeti] LeaveGroup: Portas disponíveis: ";
        for( int socktmp = 0; socktmp < MULTICAST_SOCKETS; socktmp++ )
            m_log << "socket " << socktmp << "= "
                   << multicastInfo[socktmp].myaddr_in.sin_port << " - ntohs("
                   << ntohs( multicastInfo[socktmp].myaddr_in.sin_port)
                   << ") - ";
        m_log << "" << endl;
        #endif

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - LeaveGroup] Finish 1" << endl;
        #endif

        return;
    }

    if( multicastInfo[sockIndex].socket )
    {
        //Não há a necessidade se se chamar setsockopt para IP_DROP_MEMBERSHIP
        //aqui pois ao se fechar o socket (abaixo), o próprio kernel se
        //responsabilizará por descartar os pacotes multicasts associados a este
        //socket.

        #ifdef RIO_DEBUG2
        m_log << "CLOSING SOCKET" << endl;
        #endif

        rc = close( multicastInfo[sockIndex].socket );

        if( rc != 0 )
            Rioperror( "Failed to close socket" );

    }

    multicastInfo[sockIndex].socket      = 0;
    multicastInfo[sockIndex].isConnected = false;
    memset( &(multicastInfo[sockIndex].myaddr_in), 0,
            sizeof( multicastInfo[sockIndex].myaddr_in ) );
    memset( &(multicastInfo[sockIndex].remoteaddr_in), 0,
            sizeof( multicastInfo[sockIndex].remoteaddr_in ) );

    SocketMulticastUnlock( "leaveulk" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - LeaveGroup] Finish 2" << endl;
    #endif
}

void RioNeti::mbfree

(

NetBuf *

bf

)

[private]

Definition at line 5543 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbfree] Start" << endl;
    #endif

    #ifdef WINDOWS
     // Windows implementation
    WaitForSingleObject( m_buf_lock, INFINITE );
    #else
     // Linux implementation
     pthread_mutex_lock( &m_buf_lock );
    #endif

    block->nb_link = mbc_free;
    mbc_free       = block;

    #ifdef WINDOWS
     // Windows implementation
    ReleaseMutex( m_buf_lock );
    #else
     // Linux implementation
    pthread_mutex_unlock( &m_buf_lock );
    #endif

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbfree] Finish" << endl;
    #endif
}

NetBuf * RioNeti::mbget

(

)

[private]

Definition at line 5458 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbget] Start" << endl;
    #endif

    NetBuf *fp;

    struct sockaddr_in Server;
    // A mensagem UnlockSelect e e similar a mensagem usada para manter o
    // mapeamento ativo.
    const char *UnblockSelectMsg = "UnblockSelect";
    int UnblockSelectSize = 13;

    #ifdef WINDOWS
    // Windows implementation
    WaitForSingleObject( m_buf_lock, INFINITE );
    #else
    // Linux implementation
    pthread_mutex_lock( &m_buf_lock );
    #endif

    fp = mbc_free;
    if( fp != NULL )
    {
        mbc_free = fp->nb_link;
        goto init;
    }

    fp = new NetBuf;

    if( fp != NULL )
        goto init;

    m_log << " RioNeti::mbget: malloc failed, len " << sizeof( NetBuf )
           << endl;

    abort();

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbget] Finish 1" << endl;
    #endif

    return 0;

// do some minimal initialization of this NetBuf
init:

    #ifdef WINDOWS
    // Windows implementation
    ReleaseMutex( m_buf_lock );
    #else
    // Linux implementation
    pthread_mutex_unlock( &m_buf_lock );
    #endif

    fp->nb_tidq.linkf       = fp;
    fp->nb_tidq.linkb       = fp;
    fp->nb_outrtn           = 0;    // not on output queue
    fp->nb_result           = ERROR_RIONETI;
    fp->nb_callback         = 0;
    fp->nb_blockp           = 0;
    fp->nb_bufl             = sizeof( fp->nb_buf );
    fp->nb_bufp             = fp->nb_buf;
    fp->nb_sendp            = fp->nb_buf;
    fp->nb_datap            = fp->nb_buf;
    fp->nb_rioneti          = this;
    fp->nb_unicastRequested = true;
    // Inicializa o campo nb_sendack com 1.
    fp->nb_sendack          = 1;

    // Envia a mensagem para desbloquear o select da NetMgrThread.
    Server.sin_family = AF_INET;
    Server.sin_port = m_ipport;
    Server.sin_addr.s_addr = m_ipaddr;
    sendto( m_sock, UnblockSelectMsg, UnblockSelectSize, 0,
            (const struct sockaddr *) &Server, sizeof( Server ) );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbget] Finish 2" << endl;
    #endif

    return fp;
}

void RioNeti::mbinit

(

int

num

)

[private]

Definition at line 5447 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbinit] Single" << endl;
    #endif

    mbc_num = num;
}

void RioNeti::mbterm

(

)

[private]

Definition at line 5576 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbterm] Start" << endl;
    #endif

    NetBuf *fp;
    while( mbc_free != NULL )
    {
        fp       = mbc_free;
        mbc_free = fp->nb_link;
        delete fp;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mbterm] Finish" << endl;
    #endif
}

void RioNeti::mucksockopt

(

int

fd

)

[private]

Definition at line 5658 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mucksockopt] Start" << endl;
    #endif

    int opt;

    if( m_debug & DEBUG_MISC )
    {
        m_log << " sock opt before:";
        dispsockopt( fd );
        m_log << " " << endl;
    }

    #ifdef WINDOWS
    // Windows implementation
    // opt set to 256k
    opt = 262144;
    if( setsockopt( fd, SOL_SOCKET, SO_SNDBUF, (char*)&opt, sizeof( opt ) ) )
        Rioperror( "setsockopt SO_SNDBUF" );

    if( setsockopt( fd, SOL_SOCKET, SO_RCVBUF, (char*)&opt, sizeof( opt ) ) )
        Rioperror( "setsockopt SO_RCVBUF" );
    #else
    // Linux implementation
    // ### could set to 256K or so?
    // opt = 1495040;
    opt = 655360; // 640KBytes
    if( setsockopt( fd, SOL_SOCKET, SO_SNDBUF, &opt, sizeof( opt ) ) )
        Rioperror( "setsockopt SO_SNDBUF" );

    if( setsockopt( fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof( opt ) ) )
        Rioperror( "setsockopt SO_RCVBUF" );
    #endif

    if( m_debug & DEBUG_MISC )
    {
        m_log << " sock opt after: ";
        dispsockopt( fd );
        m_log << " " << endl;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - mucksockopt] Finish" << endl;
    #endif
}

int RioNeti::nbSend	(	NetBuf *	rp,
		char *	FragmentData = NULL,
		int	FragmentSize = 0,
		int	IP = 0,
		int	Port = 0
	)

nbSend funcao para enviar um objeto NetBuf pela rede (antiga funcao iSend), se rp for diferente de NULL, e o fragmento dado pelos parametros de 2 ate 5, se rp for igual a NULL.

Parameters:

	rp	ponteiro para o objeto NetBuf a ser enviado (caso seja diferente de NULL).
	FragmentData	ponteiro para os dados do fragmento. Este parametro tambem e somente usado pelo objeto de controle de fluxo. O valor default e NULL, e isso indicara que as informacoes, passadas pelos parametros FragmentData, FragmentSize, IP e Port deverao, como ocorria na funcao iSend original, serem obtidos pelos campos nb_sendp, nb_sendl, nb_toipaddr e nb_toipport do objeto NetBuf (que devera ser diferente de NULL).
	FragmentSize	tamanho dos dados passados pelo parametro FragmentData. Tambem e somente usado pelo objeto de controle de fluxo, e o seu valor default e de 0.
	IP	endereco IP para onde o fragmento deve ser enviado. Assim como o parametro anterior, o valor default deste parametro e 0 e ele tambem e usado pelo controle de fluxo.
	Port	porta no endereco IP acima para o qual o fragmento deve ser enviado. Assim como antes, o valor defaulr sera de 0, e este parametro somente sera usado pelo controle de fluxo.

Returns:

valor diferente de 0: ocorreu um erro ao enviar o objeto NetBuf.

Definition at line 2733 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - nbSend] Start" << endl;
    #endif

    int rc;
    int ip;

    // Novas variaveis usadas pela implementacao do controle de fluxo.
    char *sendp; // Endereco dos dados a serem enviados.
    int sendl; // tamanho dos dados a serem enviados.
    int DestIP; // Endereco IP para o qual deveremos enviar o fragmento.
    int DestPort; // Porta para a qual deveremos enviar o fragmento.

    // Verifica se devemos usar ou nao os dados obtidos pelo objeto NetBuf.
    
    if( rp != NULL ) 
    {
        // Usa os valores do objeto NetBuf;
        sendp = rp->nb_sendp;
        sendl = rp->nb_sendl;
        DestIP = rp->nb_toipaddr;
        DestPort = rp->nb_toipport;
        #ifdef RIO_DEBUG2
        m_log << "[RioNeti - nbSend] NetBuf: "
              << "nb_reqid " << rp->nb_reqid
              << " nb_tiwhen " << rp->nb_tiwhen.tv_sec
              << " " << rp->nb_tiwhen.tv_usec
              << " rq_fragsh " << rp->rq_fragsh
              << " rq_fragburst " << rp->rq_fragburst
              << " rq_burstcnt " << rp->rq_burstcnt
              << " rq_fraglistn " << rp->rq_fraglistn
              << " nb_sendack " << rp->nb_sendack
              << " nb_hisreqid " << rp->nb_hisreqid
              << " nb_bufp type " << (int)((RioPkt::pktp *) rp->nb_bufp)->type
              << endl;
        #endif
    }
    else
    {
        #ifdef RIO_DEBUG2
        m_log << "[RioNeti - nbSend] rp = NULL" << endl;
        #endif
        // Usa os valores obtidos pelos parametros.
        sendp = FragmentData;
        sendl = FragmentSize;
        DestIP = IP;
        DestPort = Port;
    }
    
    #ifdef RIO_DEBUG2
    in_addr dest;
    dest.s_addr = DestIP;
    m_log << "[RioNeti - nbSend] DestIP = " << inet_ntoa( dest )
          << " , DestPort = " << htons( DestPort ) << endl;
    #endif
    
    cnt_sndpkt++;
    m_toaddr.sin_addr.s_addr = DestIP;
    m_toaddr.sin_port        = DestPort;
    ip = htonl( DestIP );
    
sendto:
    if( ( ip & htonl( inet_addr( "224.0.0.0" ) ) ) ==
        htonl( inet_addr( "224.0.0.0" ) )
      )
    {
        // Sending data with multicast address
        rc = sendto( multicastInfo[0].socket, sendp, sendl,
                     MSG_WAITALL, (struct sockaddr *)&m_toaddr, m_toaddrl );
        if( rc < 0 )
        {
            Rioperror( "nbsend[1]: " );
        }
    }
    else
    {
        #ifdef RIO_DEBUG2 
        m_log << "SendTo DEBUG UDP (nbSend):"
              << " m_sock " << (int) m_sock
              << " sendp " << (void *) sendp
              << " sendl " << (int) sendl;
        if( rp != NULL )       
            m_log << " reqid " << rp->nb_reqid << endl;
        else    
            m_log << endl;
        m_log << "RioNeti::nbSend o UDP sera usado para enviar um pacote" 
              << endl;
        #endif                  

        rc = sendto( m_sock, sendp, sendl, MSG_WAITALL,
                   (struct sockaddr *)&m_toaddr, m_toaddrl);

        #ifdef RIO_DEBUG2
        m_log << "SendTo RESLT (nbSend):"
              << " rc " << rc
              << endl;
        #endif

        if( rc < 0 )
        {
            m_log << "nbsend[2]: " << "IP = " 
                  << inet_ntoa( m_toaddr.sin_addr ) << ", port = " 
                  << ntohs( m_toaddr.sin_port ) << endl;
            Rioperror( "nbsend[2]: " );
        }
    }

    #ifdef WINDOWS
    // Windows implementation
    if( rc == SOCKET_ERROR )
    {
        /* can get ECONREFUSED on any socket operation from
           the same socket which sent a packet which caused
           an ICMP error from some host - ignore these
           (which were for a previous packet I sent)
           and resend this packet */

        if( SOCKET_ERROR == WSAECONNRESET )
        {
            #ifdef RIO_DEBUG2
            m_log << "RioNeti - Error WSAECONNRESET " << endl;
            #endif

            goto sendto;
        }

        if( SOCKET_ERROR == WSAEWOULDBLOCK )
        {
            writefdsp = &writefds; //select wake on send avail

            #ifdef RIO_DEBUG2
            m_log << "RioNeti - Error WSAEWOULDBLOCK " << endl;
            #endif

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - nbSend] Finish 4" << endl;
            #endif

            return 1;
        }
    }
    #else
    // Linux implementation
    if( rc < 0 )
    {
        /* can get ECONREFUSED on any socket operation from
        the same socket which sent a packet which caused
        an ICMP error from some host - ignore these
        (which were for a previous packet I sent)
        and resend this packet */
        if( errno == ECONNREFUSED )
        {
            #ifdef RIO_DEBUG2
            m_log << "RioNeti - Error ECONNREFUSED " << endl;
            #endif

            goto sendto;
        }

        if( errno == EAGAIN )
        {
            #ifdef RIO_DEBUG2
            m_log << "RioNeti - Error EAGAIN. Failed!! " << endl;
            #endif

            goto sendto;
        }

        if( errno == ENOBUFS )
        {
            #ifdef RIO_DEBUG2
            m_log << "RioNeti - Error ENOBUFS. Failed!! " << endl;
            #endif

            goto sendto;
        }

        #ifdef RIO_DEBUG2
        struct in_addr clientip;
        clientip.s_addr = DestIP;
        if( rp != NULL )
        {
            m_log << "RioNeti: Error nbSend to " << inet_ntoa( clientip )
                   << " port " << DestPort
                   << " frag " << rp->rq_fragsh
                   << " reqid " << rp->nb_reqid
                   << " hisreqid " << rp->nb_hisreqid
                   << " size " << sendl << endl;
            char print[256];
            sprintf(print, " sendto error rc %d, errno %d [%s]" ,
                    rc, errno, strerror(errno));
            char print2[256];
            sprintf(print, " m_sock %d sendp %p sendl %d" ,
                m_sock, sendp, sendl);
            m_log << print << endl << print2 << endl;
        }
        else
        {
            m_log << "RioNeti: Error nbSend to " << inet_ntoa( clientip )
                   << " port " << DestPort
                   << " size " << sendl << endl;
            char print[256];
            sprintf(print, " sendto error rc %d, errno %d [%s]" ,
                    rc, errno, strerror(errno));
            char print2[256];
            sprintf(print, " m_sock %d sendp %p sendl %d" ,
                m_sock, sendp, sendl);
            m_log << print << endl << print2 << endl;
        }
        if( m_debug & DEBUG_FRAG )
            NetMgr::dumppkt( " -- m_toaddr --\n",  (char *)&m_toaddr,
                             sizeof(m_toaddr));
        Rioperror( "sendto" );
        #endif
    }
    #endif

    if( m_debug & DEBUG_FRAG )
    {
        NetMgr::dumppkt(" -- sendpkt --\n", sendp, sendl);
    }

    //Linha abaixo e util para se gerar grafico de bytes enviados ao into do
    //tempo.
    if( m_LogRotation != NULL )
    {
        char StrPacketSize[ 5 ]; // O tamanho maximo do pacote sera de 1500?
        sprintf( StrPacketSize, "%d", sendl );
        if( m_LogRotation->NewLogLine( time( NULL ), StrPacketSize ) != S_OK )
            m_log << "RioNeti::nbSend erro ao escrever no log" << endl;
    }

    /*#ifdef RIO_DEBUG_EMUL
        m_log << "SENTPACKAGE " << ( int )time( NULL ) << " " << sendl << endl;
    #endif
    */
    
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - nbSend] Finish 5" << endl;
    #endif

    return 0;
}

void RioNeti::NetMgrThread

(

void

)

[private]

Definition at line 1920 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - NetMgrThread] Start" << endl;
    #endif

    int                      rc;
    NetBuf                  *rcvbuf = 0;
    NetBuf                  *nbp;
    int                     bufl = 0;
    char                    *bufp = 0;
    struct timeval           xtimeout, auxtimeout, *pxtimeout;
    bool                     anyMulticastSocket;
    bool                     IsSocketsSet;
    
    pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, NULL );
    pthread_setcanceltype(  PTHREAD_CANCEL_ASYNCHRONOUS, NULL );
    pthread_cleanup_push( RioNeti::CleanupNetMgrThread, NULL );

    if( serverInstance )
        RioErr << "NETMGRTHREADID " << syscall( SYS_gettid ) << endl;

    HashMutexLock();
loop:

    xtimeout.tv_sec  = 0;
    xtimeout.tv_usec = 0;
    pxtimeout = NULL;

    while( !DQUEUE_TEST( xm_timeq, NetBuf, nb_tidq ) )
    {
        /* process timer queue here */
        nbp = xm_timeq.linkf;
        if( ( ( xm_now.tv_usec > nbp->nb_tiwhen.tv_usec )&&
              ( xm_now.tv_sec == nbp->nb_tiwhen.tv_sec ) ) ||
              ( xm_now.tv_sec > nbp->nb_tiwhen.tv_sec ) )
        {
            /* time complete */
            DQUEUE_RMV(nbp, nb_tidq);
            nbp->nb_tidq.linkf = nbp->nb_tidq.linkb = nbp;
            //Chamando a CallBack da RioStream por timeout
            (*nbp->nb_callback)(nbp, TYPE_TIMEOUT, 0, 0);
            continue;
        }

        auxtimeout.tv_sec = nbp->nb_tiwhen.tv_sec - xm_now.tv_sec;
        auxtimeout.tv_usec = nbp->nb_tiwhen.tv_usec - xm_now.tv_usec;

        if( auxtimeout.tv_usec < 0 )
        {
            auxtimeout.tv_sec--;
            auxtimeout.tv_usec += USEC;
        }

        if( ( ( xtimeout.tv_sec == 0 ) && ( xtimeout.tv_usec == 0 ) ) ||
            ( ( ( xtimeout.tv_usec > auxtimeout.tv_usec ) &&
                ( xtimeout.tv_sec == auxtimeout.tv_sec ) ) ||
                ( xtimeout.tv_sec > auxtimeout.tv_sec ) ) )
        {
            xtimeout.tv_sec = auxtimeout.tv_sec;
            xtimeout.tv_usec = auxtimeout.tv_usec;
            pxtimeout = &xtimeout;
        }
        break;
    }

    HashMutexUnlock();

    // process completion queue (without hash lock held)
    while( m_cmpltf )
    {
        nbp = m_cmpltf;
        m_cmpltf = nbp->nb_link;
        if( m_cmpltf == 0 )
        {
            //VIRTORG abaixo pega m_cmpltf e varre procurando a origem desta
            //lista de ponteiros, retornando-a como um *NetBuf.
            m_cmpltl = VIRTORG(m_cmpltf, NetBuf, nb_link);
        }

        //Chamando a CallBack da RioStream (que chama a callback do cliente)
        (*nbp->nb_usercall)(nbp->nb_userparm, nbp->nb_result);
        mbfree( nbp );
    }

    if( m_debug & DEBUG_TIM )
    {
        char print[256];
        sprintf(print, " run now: %8.8lx %8.8lx" ,
                xm_now.tv_sec, xm_now.tv_usec);
        m_log << print << endl;
        if( m_debug & DEBUG_MORE )
            prttim( " before select" );
    }

    if( m_threadstop )
    {
        if( rcvbuf != NULL )
            mbfree( rcvbuf );

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - NetMgrThread] Finish 1" << endl;
        #endif

        return;
    }

    // select is always includes read, includes write if writefdsp (pointer)
    // is not null (when it then contains &writefds).

    FD_ZERO( &readfds );
    FD_ZERO( &writefds );

    FD_SET( m_sock, &readfds );
    FD_SET( m_sock, &writefds );

    max_in_set = m_sock;

    SocketMulticastLock();
    anyMulticastSocket = false;
    for( int socki = 0; socki < MULTICAST_SOCKETS; socki++ )
    {
        if( multicastInfo[socki].isConnected )
        {
            anyMulticastSocket = true;
            FD_SET( multicastInfo[socki].socket, &readfds );
            // the bit of multicastInfo[socki].socket is set in writefds
            //here (never changes)
            FD_SET( multicastInfo[socki].socket, &writefds );

            if( max_in_set < multicastInfo[socki].socket )
                max_in_set = multicastInfo[socki].socket;
        }
    }

    max_in_set++;

    //Se nenhum socket multicast tiver conectado, posso liberar o mutex neste
    //ponto. Isto agiliza a execução do cliente não conectado à PI e a
    //inicialização do cliente conectado à PI pois a SetMulticastSocket fica
    //presa aguardando a liberação deste mutex.
    if( !anyMulticastSocket )
        SocketMulticastUnlock();

    #ifdef WINDOWS
    // Windows implementation
       rc = select(max_in_set, &readfds, NULL,(fd_set *)0, pxtimeout);
       if( rc <= 0 )
       {
           Rioperror( "[RioNeti] select Error" );
           abort();
       }
       GetSystemTime(&pSystemTime);
       xm_now.tv_sec  = pSystemTime.wSecond;
       xm_now.tv_usec = pSystemTime.wMilliseconds;
    #else
    // Linux implementation
        //Pra tese: a chamada a SocketMulticastUnlock abaixo deveria ser feita
        //depois do select pois caso a LeaveGroup() seja chamada antes que a
        //execução passe do select o cliente irá explodir. Verificar como fazer
        //para o select abaixo se recuperar desta falha. A chamada a
        //SocketMulticastUnlock(0 abaixo está aqui até quando este problema for
        //resolvido, quando deverá ser colocada após o select.
        SocketMulticastUnlock();

        rc = select( max_in_set, &readfds, writefdsp, (fd_set *)0, pxtimeout );

        if( rc == -1 )
        {
            if( errno == 4 ) //Error #4: Interrupted system call
            {
                 #ifdef RIO_DEBUG2
                 m_log << "RioNeti::NetMgrThread recebi o erro que a chamada  "
                       << "ao sistena foi interrompida. Saltando para o loop" 
                       << endl;
                 #endif

                 goto loop;
            }
            else if( errno == EBADF )
            {
                 // Se este erro ocorrer, devemos ignora-lo pois isso significa
                 // que as conexoes TCP foram fechadas apos os conjuntos do
                 // select terem sido definidos (note que somente o cliente 
                 // fecha os seus sockets TCP).
                 
                 #ifdef RIO_DEBUG2
                 m_log << "RioNeti::NetMgrThread recebi o erro EBADF. "
                       << "Saltando para o loop" << endl;
                 #endif

                 goto loop;
            }
            else
            {
                #ifdef RIO_DEBUG2
                m_log << "[NetMgrThread] Erro " << errno << ". Sockets values:"
                       << " unicast: " << m_sock << ", multicasts: "
                       << multicastInfo[0].socket << "/"
                       << multicastInfo[1].socket << endl;
                #endif

                Rioperror( "Unable to Select Socket" );
                abort();
            }
        }
        gettimeofday(&xm_now, NULL);
    #endif

    for( int socki = 0; socki < MULTICAST_SOCKETS; socki++ )
    {
        if( multicastInfo[socki].isConnected &&
            FD_ISSET( multicastInfo[socki].socket, &readfds )
          )
        {
receivemcast:
            if( !rcvbuf )
            {
                rcvbuf = mbget();
                bufp   = rcvbuf->nb_buf;
                bufl   = sizeof( rcvbuf->nb_buf );
            }
            m_fraddrl = sizeof( m_fraddr );

            int groupl = sizeof(multicastInfo[socki].remoteaddr_in);

            #ifdef WINDOWS
            // Windows implementation
            rc = recvfrom( multicastInfo[socki].socket, bufp, bufl, 0,
                       (struct sockaddr *)&(multicastInfo[socki].remoteaddr_in),
                       (int FAR*) &groupl);

            #else
            // Linux implementation
            rc = recvfrom( multicastInfo[socki].socket, bufp, bufl, MSG_WAITALL,
                       (struct sockaddr *) &multicastInfo[socki].remoteaddr_in,
                       (socklen_t *) &groupl );
            #endif

            #ifdef WINDOWS
            // Windows implementation
            if( rc == SOCKET_ERROR )
            {
                if( rc == WSAEWOULDBLOCK )
                {
                    #ifdef RIO_DEBUG2
                    m_log << "RioNeti - erro socket WSAEWOULDBLOCK " << endl;
                    #endif

                    goto unicastreceive;
                }
                // just ignore connection refused, lost pkt will timeout
                if( SOCKET_ERROR == WSAECONNRESET )
                {
                    #ifdef RIO_DEBUG2
                    m_log << "RioNeti - erro socket WSAECONNRESET " << endl;
                    #endif

                    goto unicastreceive;
                }
                if( SOCKET_ERROR == -1 )
                {
                    goto unicastreceive;
                }
                if( rc == 10004 )
                {
                    goto receivemcast;
                }
                goto unicastreceive;
            }
            #else
            // Linux implementation
            if( rc == -1 )
            {
                if( errno == EAGAIN )
                {
                    goto unicastreceive;
                }
                // just ignore connection refused, lost pkt will timeout
                if( errno == ECONNREFUSED )
                {
                    #ifdef RIO_DEBUG2
                    m_log << "RioNeti - erro socket ECONNREFUSED " << endl;
                    #endif

                    goto unicastreceive;
                }

                #ifdef RIO_DEBUG2
                struct in_addr clientip;
                clientip.s_addr =
                            multicastInfo[socki].remoteaddr_in.sin_addr.s_addr;
                m_log << "RioNeti: Error Received from " << inet_ntoa(clientip)
                       << " port " << multicastInfo[socki].remoteaddr_in.sin_port
                       << "(" << rc << ")" << endl;
                Rioperror( "recvfrom" );
                #endif

                if( errno == EINTR )
                {
                    #ifdef RIO_DEBUG2
                    m_log <<" Thread " << pthread_self() <<  " error EINTR "
                           << endl;
                    #endif

                    goto receivemcast;
                }

                #ifdef RIO_DEBUG2
                m_log << ( unsigned int ) pthread_self()
                       << " NetMgrThread receive error: errno "
                       << errno << "  [" << strerror(errno) << " ]" << endl;
                #endif

                goto unicastreceive;
            }
            #endif

            rcvbuf->nb_recvl = rc;
            if( m_debug & DEBUG_DATA )
            {
                m_log << " received len " << rc << endl;
            }

            // process pkt, might eat buffer too
            procpkt( &rcvbuf, MULTICASTTRAFFIC );
            goto receivemcast;    // try for more inbound packets
        } // fim do if( FD_ISSET( multicastInfo[socki].socket, &readfds ) )
    } // fim do for( int i = 0; i < MULTICAST_SOCKETS; i++ )

unicastreceive:

    if( FD_ISSET( m_sock, &readfds ) )
    {
receive:
        if( !rcvbuf )
        {
            rcvbuf = mbget();
            bufp   = rcvbuf->nb_buf;
            bufl   = sizeof( rcvbuf->nb_buf );
        }
        m_fraddrl = sizeof( m_fraddr );
        // ## why is length an int for send and unsigned int for recv?

        #ifdef WINDOWS
        // Windows implementation
        rc = recvfrom(m_sock, bufp, bufl, 0,(struct sockaddr *)&m_fraddr,
            (int FAR*) &m_fraddrl);

        if( rc == SOCKET_ERROR )
        {
            if( rc == WSAEWOULDBLOCK )
            {
                #ifdef RIO_DEBUG2
                m_log << "RioNeti - erro socket unicast WSAEWOULDBLOCK"
                       << endl;
                #endif

                goto send;
            }
            // just ignore connection refused, lost pkt will timeout
            if( SOCKET_ERROR == WSAECONNRESET )
            {
                #ifdef RIO_DEBUG2
                m_log << "RioNeti - erro socket unicast WSAECONNRESET" << endl;
                #endif

                goto send;
            }
            if( SOCKET_ERROR == -1 )
            {
                #ifdef RIO_DEBUG2
                m_log << "rioneti - socket error -1 " << strerror(errno)
                       << endl;
                #endif

                goto send;
            }
            if( rc == 10004 )
            {
                #ifdef RIO_DEBUG2
                m_log << "rioneti11 - socket error: " << strerror(errno)
                       << endl;
                #endif

                goto receive;
            }

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - NetMgrThread] Finish 2" << endl;
            #endif

            exit(1);
        }
        #else
        // Linux implementation
        rc = recvfrom( m_sock, bufp, bufl, MSG_WAITALL,
                       (struct sockaddr *)&m_fraddr,
                       (socklen_t *) &m_fraddrl );

        if( rc == -1 )
        {
            if( errno == EAGAIN )
            {
                goto send;
            }
            // just ignore connection refused, lost pkt will timeout
            if( errno == ECONNREFUSED )
            {
                #ifdef RIO_DEBUG2
                m_log << "RioNeti - erro socket unicast ECONNREFUSED" << endl;
                #endif

                goto send;
            }

            #ifdef RIO_DEBUG2
            struct in_addr clientip;
            clientip.s_addr = m_fraddr.sin_addr.s_addr;
            m_log << "RioNeti: Error Received UDP from " << inet_ntoa(clientip)
                   << " port " << m_fraddr.sin_port
                   << "(" << m_fraddrl << ")" << "(" << rc << ")" << endl;
            Rioperror( "recvfrom" );
            #endif

            if( errno == EINTR )
            {
                #ifdef RIO_DEBUG2
                m_log <<" Thread " << pthread_self() <<  " error EINTR "
                      << endl;
                #endif

                goto receive;
            }

            #ifdef RIO_DEBUG2
            m_log << ( unsigned int )pthread_self() << " NetMgrThread receive error: errno "
                   << errno
                   << "  ["  << strerror(errno) << " ]"  << endl;
            #endif

            goto send;
        }
        #endif

        rcvbuf->nb_recvl = rc;
        if( m_debug & DEBUG_DATA )
        {
            m_log << " received len " << rc << endl;
        }

        // process pkt, might eat buffer too
        procpkt( &rcvbuf, UNICASTTRAFFIC );
        goto receive;        // try for more inbound packets
    } // fim do if( FD_ISSET( m_sock, &readfds ) )

send:
    // writefds always has my socket bit set if writefdsp is 0;
    // thus the delayed output list can be used to make a send after
    // receive processing is complete even if sends are working
    // (and writefdsp is 0)
    HashMutexLock(); //lock for writefdsp & later timer code
    // Verifica os sockets UDP
    IsSocketsSet = FD_ISSET( m_sock, &writefds );

    if( IsSocketsSet )
    {
        writefdsp = 0;    // no write/send wakeup needed (yet)
        // process output queue by removing each NetBuf and calling it's
        // nb_outrtn (as int as iSend hasn't failed (writefdsp set)).

        while( m_outqf && !writefdsp )
        {
            nbp = m_outqf;
            void(*rtn)(NetBuf *) = nbp->nb_outrtn;
            m_outqf = nbp->nb_outnext;
            if( nbp == m_outql )
            {
                m_outql = VIRTORG(m_outqf, NetBuf, nb_outnext);
            }
            nbp->nb_outrtn = 0;    // not on out queue
            // hash lock held, must not be released
            if( m_debug & DEBUG_MISC )
            {
                char print[256];
                sprintf(print, " out-disp - %p" , nbp);
                m_log << print << endl;
            }
            (*rtn)(nbp);
        } // fim do while( m_outqf && !writefdsp )
    } // fim do if( IsSocketsSet )

    goto loop;

    //TODO: Esta linha abaixo nunca será executada por causa do goto acima.
    //Verificar se isto tem relação com a explosão que acontece com o cliente
    //quando ele é finalizado (em poucas ocasiões). Acontece que enquanto
    //algumas classes estão sendo deletadas pode chegar um novo bloco e isto faz
    //com que a CallBack seja chamada. Neste caso há um sigsegv. Isto ainda não
    //foi consertado pois acontece quando o cliente está pra ser finalizado, o
    //que não atrapalha ninguém.
    pthread_cleanup_pop( 1 );
}

void * RioNeti::NetMgrThreadEp

(

void *

parm

)

[static, private]

Definition at line 1887 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - NetMgrThreadEp] Start" << endl;
    #endif

    #ifdef RIO_DEBUG2
    m_log << "[RioNeti - NetMgrThreadEp] Eu sou a NetMgrThread." << endl;
    #endif

    RioNeti *netiPtr = (RioNeti *) parm;

    netiPtr->NetMgrThread();

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - NetMgrThreadEp] Finish" << endl;
    #endif

    return 0;
}

void RioNeti::procpkt	(	NetBuf **	rcvbuf,
		RioStreamType	traffic = UNICASTTRAFFIC
	)			[private]

Definition at line 4281 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpkt] Start" << endl;
    #endif
    
    char         *pktp;
    int           pktl;
    RioPkt::pktp *p;
    RioPkt::pktpmap *pmap;
    NetBuf       *rp;
    call_type     type;
    int           reqid;
    int           hisreqid;
    int           serverid;

    #ifdef RIO_DEBUG2
    // Variavel usada para depurar o codigo.
    struct sockaddr_in mymapip;
    #endif

    NetBuf *nbp = *rcvbuf;
    pktp        = nbp->nb_bufp;
    pktl        = nbp->nb_recvl;

    cnt_rcvpkt++;        // no lock but only this thread touches cnt

    if( m_debug & DEBUG_DATA )
        NetMgr::dumppkt( " -- procpkt --\n", pktp, pktl );

    // all packets start with type byte
    type = (call_type) ( ((RioPkt::pktp *)pktp)->type );
    reqid = ( ( RioPkt::pktp * ) pktp )->reqid;

    #ifdef RIO_DEBUG2
    m_log << "[RioNeti - procpkt] Received packet: type " << type 
          << ", reqid = " << reqid << ", ip = " 
          << inet_ntoa( m_fraddr.sin_addr ) << ", porta = " 
          << ntohs( m_fraddr.sin_port ) << endl;
    #endif

    switch( type )
    {
        case TYPE_FRAG:
            procpktfrag( pktp, pktl, traffic );
            break;

        case TYPE_FRAGACK:
            procpktfragack( pktp, pktl );
            break;

        case TYPE_RST:
            procpktrst( pktp, pktl );
            break;

        case TYPE_ACK:
            reqid = ((RioPkt::pktp *)pktp)->reqid;
            HashMutexLock( "prcpkt1" );
            rp = iHashFind( reqid );
            if( !rp )
            {
                #ifdef RIO_DEBUG2
                m_log << "RioNeti: did not find reqid "<< reqid << endl;
                #endif

                HashMutexUnlock( "prcpkt2" );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 1" << endl;
                #endif

                return;
            }
            
            #ifdef RIO_DEBUG2
            m_log << "[RioNeti - procpkt TYPE_ACK] NetBuf: "
                  << "nb_reqid " << rp->nb_reqid
                  << " nb_tiwhen " << rp->nb_tiwhen.tv_sec
                  << " " << rp->nb_tiwhen.tv_usec
                  << " rq_fragsh " << rp->rq_fragsh
                  << " rq_fragburst " << rp->rq_fragburst
                  << " rq_burstcnt " << rp->rq_burstcnt
                  << " rq_fraglistn " << rp->rq_fraglistn
                  << " nb_sendack " << rp->nb_sendack
                  << " nb_hisreqid " << rp->nb_hisreqid
                  << " nb_bufp type " << (int)((RioPkt::pktp *) rp->nb_bufp)->type
                  << endl;
            #endif
            
            p = (RioPkt::pktp *)pktp;
            if( !p->auth.checkauth(pktp, pktl, rp) )
            {
                HashMutexUnlock( "prcpkt3" );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 2" << endl;
                #endif

                return;
            }
            pktp    += sizeof( RioPkt::pktp );
            pktl    -= sizeof( RioPkt::pktp );
            
            // note called with lock must not free lock...
            (rp->nb_callback)( rp, type, pktp, pktl );
            HashMutexUnlock( "prcpkt4" );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - procpkt] Finish 3" << endl;
            #endif

            return;

        case TYPE_RESULT:
            p = (RioPkt::pktp *)pktp;
            reqid    = p->reqid;
            hisreqid = *((u32 *)( pktp + sizeof( RioPkt::pktp ) ));
            HashMutexLock( "prcpkt5" );
            rp = iHashFind( reqid );
            if( !rp )
            {
                HashMutexUnlock( "prcpkt6" );

                #ifdef RIO_DEBUG2
                m_log << "RioNeti: did not find reqid "<< reqid << endl;
                #endif

                SendRst( m_fraddr.sin_addr.s_addr,
                         m_fraddr.sin_port,
                         p->reqid, 0xe11e );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 4" << endl;
                #endif

                return;
            }
            
            #ifdef RIO_DEBUG2
            m_log << "[RioNeti - procpkt TYPE_RESULT] NetBuf: "
                  << "nb_reqid " << rp->nb_reqid
                  << " nb_tiwhen " << rp->nb_tiwhen.tv_sec
                  << " " << rp->nb_tiwhen.tv_usec
                  << " rq_fragsh " << rp->rq_fragsh
                  << " rq_fragburst " << rp->rq_fragburst
                  << " rq_burstcnt " << rp->rq_burstcnt
                  << " rq_fraglistn " << rp->rq_fraglistn
                  << " nb_sendack " << rp->nb_sendack
                  << " nb_hisreqid " << rp->nb_hisreqid
                  << " nb_bufp type " << (int)((RioPkt::pktp *) rp->nb_bufp)->type
                  << endl;
            #endif

            p = (RioPkt::pktp *)pktp;
            if( !p->auth.checkauth( pktp, pktl, rp ) )
            {
                HashMutexUnlock( "prcpkt7" );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 5" << endl;
                #endif

                return;
            }

            iSendAck( m_fraddr.sin_addr.s_addr, m_fraddr.sin_port, hisreqid );

            pktp    += sizeof( RioPkt::pktp ) + sizeof( u32 );
            pktl    -= sizeof( RioPkt::pktp ) + sizeof( u32 );

            // note called with lock must not free lock...
            (rp->nb_callback)( rp, type, pktp, pktl );
            HashMutexUnlock( "prcpkt8" );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - procpkt] Finish 6" << endl;
            #endif

            return;

        case TYPE_CMD:
            p = (RioPkt::pktp *)pktp;
            reqid = p->reqid;
            // reqid == 0 means global SetCmd otherwise should be
            //ExpectCmd pending
            HashMutexLock( "prcpkt9" );
            if( reqid == 0 )
            {
                nbp->nb_usercmd  = m_cmdproc;
                nbp->nb_userparm = m_cmdparm;
                rp = 0;
            }
            else
            {
                rp = iHashFind( reqid );
                if( rp )
                {
                    // ### could check really is ExpectCmd NetBuf?
                    nbp->nb_usercmd  = rp->nb_usercmd;
                    nbp->nb_userparm = rp->nb_userparm;
                }
                else
                {
                    // Este caso nao estava sendo tratado. Caso a reqid nao
                    // exista na hash de reqids dos NetBufs atualmente usados,
                    // precisamos gerar a mensagem SendRst e sair.
                    HashMutexUnlock( "prcpkt10" );
 
                    #ifdef RIO_DEBUG2
                    m_log << "RioNeti: did not find reqid "<< reqid << endl;
                    #endif

                    SendRst( m_fraddr.sin_addr.s_addr,
                             m_fraddr.sin_port,
                             p->reqid, 0xe11e );

                    #ifdef RIO_DEBUG1
                    m_log << "[RioNeti - procpkt] Finish 7" << endl;
                    #endif

                    return;
                }
            }
            if( !p->auth.checkauth( pktp, pktl, rp ) )
            {
                HashMutexUnlock( "prcpkt11" );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 8" << endl;
                #endif

                return;
            }

            hisreqid = *((u32 *)( pktp + sizeof( RioPkt::pktp ) ));
            pktp    += sizeof( RioPkt::pktp ) + sizeof( u32 );
            pktl    -= sizeof( RioPkt::pktp ) + sizeof( u32 );

            iSendAck( m_fraddr.sin_addr.s_addr, m_fraddr.sin_port, hisreqid );

            if( nbp->nb_usercmd == 0 )
            {
                HashMutexUnlock( "prcpkt12" );
                SendRst( m_fraddr.sin_addr.s_addr, m_fraddr.sin_port,
                         p->reqid, 0xe00e );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 9" << endl;
                #endif

                return;
            }
            HashMutexUnlock( "prcpkt13" );
            (nbp->nb_usercmd)( nbp->nb_userparm, pktp, pktl );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - procpkt] Finish 10" << endl;
            #endif

            return;

        // Novo tipo de chamada usado para fazer um pedido de mapeamento: 
        // retorna o endereco que enviou o pedido, ou seja, o IP e a porta
        // de origem do pedido (feito por um cliente que dejesa descobrir se
        // esta atras ou nao de NAT).    
        case TYPE_SENDMAP:
            p = (RioPkt::pktp *)pktp;
            hisreqid = *((u32 *)( pktp + sizeof( RioPkt::pktp ) ));

            HashMutexLock( "prcpkt14" ); // Isso e necessario?

            // Comentei este codigo pois ele nao parece necessario. Estou 
            // correto?
            /*rp = 0;

            if( !p->auth.checkauth( pktp, pktl, rp ) )
            {
                HashMutexUnlock( "prcpkt15" ); // Isso e necessario?

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 11" << endl;
                #endif

                return;
            }*/

            #ifdef RIO_DEBUG2
            m_log << "RioNeti::procpkt SENDMAP enviando ACK IP = "
                   << inet_ntoa( m_fraddr.sin_addr ) 
                   << ", porta = " << ntohs( m_fraddr.sin_port ) 
                   << ", reqid = " << p->reqid << endl; 
            #endif

            // Envia um ACK especial contendo o endereco IP e a porta de quem
            // fez a chamada do tipo TYPE_SENDMAP. 
            iSendMapAck( m_fraddr.sin_addr.s_addr, m_fraddr.sin_port, 
                         hisreqid );

            HashMutexUnlock( "prcpkt16" ); // Isso e necessario?

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - procpkt] Finish 12" << endl;
            #endif
            return;
            
        // Novo tipo de chamada usado para receber um ACK especial com o
        // mapeamento: extrai o endereco IP e a porta do ACK, e atualiza as 
        // variaveis m_ipaddrmap, m_ipportmap e m_behindnat de acordo com
        // os dados do ACK. Para podermos lidar com a possibilidade de 
        // recebimento de multiplos ACKs, a variavel m_receivedmap, 
        // inicialmente igual a false, e mudada para true apos a primeira
        // mensagem de ACK ser recebida, para evitar inicializacoes adicionais
        // das variaveis m_ipaddrmap, m_ipportmap e m_behindnat. Depois de 
        // inicializar as variaveis, a funcao de callback e chamada para
        // informar, a quem fez a chamada a funcao RequestMapping, que
        // o mapeamento ja foi obtido. 
        case TYPE_MAPACK:
            reqid = ((RioPkt::pktpmap *)pktp)->reqid;
            
            // Procura pela reqid na tabela.
            
            serverid = -1;
            for (unsigned int i = 0; i < m_MappingInfoSize; i++ )
            {
                if( m_MappingInfo[ i ].reqid == reqid )
                {
                    serverid = i;
                    break;
                }    
            }
            
            if( serverid == -1 )
            {
                #ifdef RIO_DEBUG2
                m_log << "RioNeti: did not find reqid in m_MappingInfo" << reqid 
                      << endl;
                #endif

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 13" << endl;
                #endif

                return;
            }
 
            HashMutexLock( "prcpkt17" );
            rp = iHashFind( reqid );

            if( !rp )
            {
                #ifdef RIO_DEBUG2
                m_log << "RioNeti: did not find reqid "<< reqid << endl;
                #endif

                HashMutexUnlock( "prcpkt18" );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 13" << endl;
                #endif

                return;
            }

            #ifdef RIO_DEBUG2
            m_log << "[RioNeti - procpkt TYPE_MAPACK] NetBuf: "
                  << "nb_reqid " << rp->nb_reqid
                  << " nb_tiwhen " << rp->nb_tiwhen.tv_sec
                  << " " << rp->nb_tiwhen.tv_usec
                  << " rq_fragsh " << rp->rq_fragsh
                  << " rq_fragburst " << rp->rq_fragburst
                  << " rq_burstcnt " << rp->rq_burstcnt
                  << " rq_fraglistn " << rp->rq_fraglistn
                  << " nb_sendack " << rp->nb_sendack
                  << " nb_hisreqid " << rp->nb_hisreqid
                  << " nb_bufp type " << (int)((RioPkt::pktp *) rp->nb_bufp)->type
                  << endl;
            #endif
            
            pmap = (RioPkt::pktpmap *)pktp;
            
            #ifdef RIO_DEBUG2
            struct in_addr ip;
            ip.s_addr = pmap->IP;
            m_log << "[RioNeti - procpkt] Received mapping #" << serverid
                  << endl;
            m_log << "[RioNeti - procpkt] " << inet_ntoa( ip )
                  << " , " << htons( pmap->port ) << endl;
            #endif
 
            // O identificador do servidor ao qual foi pedido o mapeamento e o
            // reqid do pedido.
            // Verifica se o cliente esta atras de NAT.
            if( pmap->IP != (unsigned int)m_ipaddrmap[ serverid ] )
            {
                m_ipaddrmap[serverid] = pmap->IP;
                m_ipportmap[serverid] = pmap->port;
                // Note que nao devemos comparar as portas, pois alguns NATs
                // tentam preservar o numero da porta. Porem, se o cliente
                // estiver atras de NAT, os IPs deverao ser diferentes.
                m_behindnat = ( m_ipaddrmap[serverid] !=
                                m_ipaddr );
            }
            // Informa que uma mensagem de mapeamento foi recebida para o 
            // servidor e marca o servidor como ativo.
            m_MappingInfo[ serverid ].IsEnabled = true;
            
            if( !pmap->auth.checkauth(pktp, pktl, rp) )
            {
                HashMutexUnlock( "prcpkt19" );

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpkt] Finish 14" << endl;
                #endif

                return;
            }

            pktp    += sizeof( RioPkt::pktpmap );
            pktl    -= sizeof( RioPkt::pktpmap );

            #ifdef RIO_DEBUG2
            mymapip.sin_addr.s_addr = rp->nb_toipaddr;
            m_log << "RioNeti::procpkt recebendo MAPACK IP = " 
                   << inet_ntoa( mymapip.sin_addr ) 
                   << ", porta = " << ntohs( rp->nb_toipport ) 
                   << ", reqid = " << reqid << endl;
            #endif           

            // note called with lock must not free lock...
            (rp->nb_callback)( rp, type, pktp, pktl );
            
            HashMutexUnlock( "prcpkt20" );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - procpkt] Finish 15" << endl;
            #endif
            return;

        default:
            err_pktcmd++;
            
            #ifdef RIO_DEBUG2
            m_log << "[RioNeti - procpkt default] type "
                  << (int)((RioPkt::pktp *) pktp)->type
                  << endl;
            #endif

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - procpkt] Finish 16" << endl;
            #endif

            return;

    }  // end of switch on type

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpkt] Finish 17" << endl;
    #endif
}

void RioNeti::procpktfrag	(	char *	pktp,
		int	pktl,
		RioStreamType	traffic = UNICASTTRAFFIC
	)			[private]

Definition at line 3711 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpktfrag] Start" << endl;
    #endif

    int               num;
    RioNetiReqIdItem *current  = NULL;
    RioNetiReqIdItem *previous = NULL;
    RioPkt::pktfx    *p = (RioPkt::pktfx *)pktp;

    HashMutexLock();

    //contador de fragmentos recebidos para o pacote atual
    num = ntohs( p->fragnum );

    #ifdef RIO_DEBUG2
    m_log << "[RioNeti - procpktfrag] fragnum = " << num << ", reqid = "
          << p->reqid << endl;
    #endif

    //FIXME: The PL must not pass through here.
    //A informação traffic abaixo é fornecida pelo socket, pois ele sabe se o
    //pacote veio por uma conexão multicast ou unicast. Com isto a
    //NetMgrThread sabe que a função de CallBack a ser chamada é a
    //MulticastCallBack (recebimento de blocos multicast) em vez da CallBack
    //(recebimento de blocos unicast).
    if( ( traffic == MULTICASTTRAFFIC ) && callback_transport )
    {
        callback_t client_callback = callback_transport->callback;

        callback_transport->block = p->reqid;

        int result = reqid_table->Search( p->reqid, &current, &previous );

        if( ( result == RESULT_NETIREQT_SEARCH_NOT_FOUND  ) ||
            ( result == RESULT_NETIREQT_SEARCH_EMPTY_LIST )
          )
        {
            RioCallBackTransport *multicast_callback;
            multicast_callback                = new RioCallBackTransport;
            multicast_callback->block         = p->reqid;
            multicast_callback->callback      = this->callback;
            multicast_callback->stream        = callback_transport->stream;
            multicast_callback->object        = callback_transport->object;
            multicast_callback->main_callback =
                                        callback_transport->main_callback;

            RioNetiReqIdItem *item = new RioNetiReqIdItem( p->reqid );

            //Criando um item na tabela reqid_table para agrupar os fragmentos
            //deste bloco. quando o último fragmento chegar este item será
            //removido da tabela (feito no final deste método).
            reqid_table->Insert( item );

            char *auxBuf = new char[ buffer_stream->getBlockSize() ];
            item->SetBuf( auxBuf );

            //FIXME: Esta linha já é executada 27 linhas acima. Verificar se ele
            //é mesmo necessária aqui neste local (se nenhum dos métodos
            //chamados daquele ponto até este aqui alteram este valor).
            callback_transport->block = p->reqid;

            HashMutexUnlock();

            #ifdef RIO_DEBUG2
            m_log << "[procpktfrag] Chamando ExpectData. "
                   << "callback_transport->block = "
                   << callback_transport->block << endl;
            #endif

            int localreqid = ExpectData( auxBuf,
                                         buffer_stream->getBlockSize(),
                                         client_callback, multicast_callback,
                                         MULTICASTTRAFFIC, 0 );

            HashMutexLock();

            item->SetLreqid( localreqid );
            current  = item;
            p->reqid = current->GetLreqid();

            #ifdef RIO_DEBUG2
            m_log << "[RioNeti] reqid " << p->reqid << " é relativo ao bloco "
                   << callback_transport->block << endl;
            #endif

            //Fornencendo o bloco de vídeo a ser gravado no PlayOutBuffer.
            multicast_callback->data = current->GetBuf();

            #ifdef RIO_DEBUG2
            m_log << "[1]recebido fragmento " << num << " do bloco de reqid "
                   << current->GetPreqid() << ", traffic = " << traffic
                   << endl;
            #endif
        }
        else
        {
            #ifdef RIO_DEBUG2
            m_log << "[2]recebido fragmento " << num << " do bloco de reqid "
                   << p->reqid << ", traffic = MULTICASTTRAFFIC" << endl;
            #endif

            if( result == RESULT_NETIREQT_SEARCH_FOUND )
            {
                p->reqid = current->GetLreqid();
            }
            else
            {
                #ifdef RIO_DEBUG2
                m_log << "RioNeti - retornando da procpkt " << endl;
                #endif

                HashMutexUnlock();

                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - procpktfrag] Finish 1" << endl;
                #endif

                return;
            }
        }
    }
    #ifdef RIO_DEBUG2
    else
    {
        m_log << "[3]recebido fragmento " << num << " do bloco de reqid "
               << p->reqid << ", traffic = " << traffic << endl;
    }
    #endif

    NetBuf *rp = iHashFind( p->reqid );
    if( !rp )
    {
        //Aqui se trata dos fragmentos solicitados mas que chegaram atrasados,
        //isto e, depois que o bloco foi removido da tabela hash(possivelmente
        //para exibicao imediata)
        #ifdef RIO_DEBUG2
        if( traffic == MULTICASTTRAFFIC && callback_transport )
        {
            m_log << "Nao encontrado na tabela Hash o bloco multicast "
                   << current->GetPreqid() << " para este fragmento de "
                   << "numero " << num << endl;
        }
        else
        {
            m_log << "Nao encontrado na tabela Hash o bloco unicast "
                   << p->reqid << " para este fragmento de numero " << num
                   << endl;
        }
        #endif

        //Linha abaixo é útil para se gerar gráfico de fragmentos atrasados ao
        //into do tempo.
        #ifdef RIO_DEBUG2
        m_log << "DELAYEDPACKAGE " << (int)time(NULL) << " 1456.4" << endl;
        #endif

        HashMutexUnlock();

        SendRst( m_fraddr.sin_addr.s_addr, m_fraddr.sin_port, p->reqid,
                 0xe11f );

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - procpktfrag] Finish 2" << endl;
        #endif

        return;
    }
            
    #ifdef RIO_DEBUG2
    m_log << "[RioNeti - procpktfrag] NetBuf: "
          << "nb_reqid " << rp->nb_reqid
          << " nb_tiwhen " << rp->nb_tiwhen.tv_sec
          << " " << rp->nb_tiwhen.tv_usec
          << " rq_fragsh " << rp->rq_fragsh
          << " rq_fragburst " << rp->rq_fragburst
          << " rq_burstcnt " << rp->rq_burstcnt
          << " rq_fraglistn " << rp->rq_fraglistn
          << " nb_sendack " << rp->nb_sendack
          << " nb_hisreqid " << rp->nb_hisreqid
          << " nb_bufp type " << (int)((RioPkt::pktp *) rp->nb_bufp)->type
          << endl;
    #endif

    if( (unsigned)pktl <= sizeof( RioPkt::pktfx ) )
    {
        err_pktsize++;

        #ifdef RIO_DEBUG2
        if( traffic == MULTICASTTRAFFIC && callback_transport )
        {
            m_log << "RioNeti - Erro multicast - " << num << "/"
                   << rp->rq_fraghav << " bloco: " << current->GetPreqid()
                   << endl;
        }
        else
        {
            m_log << "RioNeti - Erro unicast - " << num << "/"
                   << rp->rq_fraghav << " reqid: " << p->reqid << endl;
        }
        #endif

        goto unlockret;
    }

    if( m_debug & DEBUG_FRAG )
        m_log << " procpkt frag " << num << endl;

    if( ( unsigned )num > sizeof( rp->rq_bits ) )
    {
        // ### invalid fragment number...
        err_pktfmt++;

        #ifdef RIO_DEBUG2
        if( traffic == MULTICASTTRAFFIC && callback_transport )
        {
            m_log << "RioNeti1 - multicast - " << num << "/" << rp->rq_fraghav
                   << " bloco: " << current->GetPreqid() << endl;
        }
        else
        {
            m_log << "RioNeti1 - unicast - " << num << "/" << rp->rq_fraghav <<
                      " reqid: " << p->reqid << endl;
        }
        #endif

        goto unlockret;
    }

    //O ifdef abaixo pode ser usado para simular perdas de fragmentos. Para
    //isto, escolha os fragmentos a serem perdidos e execute "goto unlockret"
    #ifdef DEBUGFRAGACK //drop fragments
    if( ( num == 20 ) || ( num == 40 )  )
    {
        //descartar frags multiplos de 20
        m_log << "[PROCPKTFRAG ] Descartando fragmento " << num
               << " do bloco de reqid " << p->reqid << ", traffic = " << traffic
               << endl;

        goto unlockret;
    }
    //descartando o quinto fragmento do bloco de reqid 5
    //if( p->reqid == 5 && num == 5  ) goto unlockret;
    #endif

    --rp->rq_needack;        // ack every Nth fragment

    if( rp->rq_bits[ num ] )// dup fragment
    {
        err_dupfrag++;
        if( rp->rq_needack > 0 )
            rp->rq_needack = 0;    // force ack

        #ifdef RIO_DEBUG2
        if( traffic == MULTICASTTRAFFIC && callback_transport )
        {
            m_log << "ack1 multicast - " << num << "/" << rp->rq_fraghav
                   << " bloco: " << current->GetPreqid() << endl;
        }
        else
        {
            m_log << "ack1 unicast - " << num << "/" << rp->rq_fraghav <<
                      " reqid: " << p->reqid << endl;
        }
        #endif

        goto checkack;
    }

    char *dp;
    if( num == 0 )// 0th fragment is special (also isn't dup pkt )
    {
        #ifdef RIO_DEBUG2
        if( rp->nb_unicastRequested )
            m_log << "[procpktfrag] Recebendo fragmento zero do bloco unicast "
                   << "de reqid " << rp->nb_reqid << endl;
        else
            m_log << "[procpktfrag] Recebendo fragmento zero do bloco "
                   << "multicast de reqid " << rp->nb_reqid << endl;
        #endif

        rp->rq_needack     = 0; // force ack
        rp->nb_hisreqid    = ( ( RioPkt::pktf0 * )pktp )->ackreqid;
        rp->nb_frag0arrive = time( NULL );
        rp->rq_fragmax     = ntohs( ( ( RioPkt::pktf0 * ) pktp )->fragmax) ;
        rp->rq_maxpktl     = ntohs( ( ( RioPkt::pktf0 * )pktp )->maxpktl );
        rp->rq_fraglen     = rp->rq_maxpktl
                           - (iphdrlen + udphdrlen + sizeof( RioPkt::pktfx ));
        rp->rq_fraglen0    = rp->rq_maxpktl
                           - (iphdrlen + udphdrlen + sizeof( RioPkt::pktf0 ));
        rp->nb_toipaddr    = m_fraddr.sin_addr.s_addr;
        rp->nb_toipport    = m_fraddr.sin_port;
        dp = rp->nb_blockp;
        pktp += sizeof( RioPkt::pktf0 );
        pktl -= sizeof( RioPkt::pktf0 );
        if( m_debug & DEBUG_FRAG )
        {
            char print[256];
            sprintf( print, " ---frag 0: ipaddr %8.8x port %8.8x",
                     (unsigned int)rp->nb_toipaddr,
                     (unsigned int)rp->nb_toipport );
            m_log << print << endl;
            NetMgr::dumppkt( " -- m_fraddr --\n",
                             (char *)&m_fraddr, sizeof( m_fraddr ) );
        }
    }
    else
    {
        // ignore fragment if don't have info from frag 0 yet..
        if( rp->rq_fraghav == 0 )
        {
            //Todo fragmento que chega antes do fragmento zero é descartado.
            //Contabilizando os fragmentos descartados do bloco.
            rp->rq_fragDiscarded++;

            #ifdef RIO_DEBUG2
            if( rp->nb_unicastRequested )
                m_log << "[procpktfrag] Descartando fragmento " << num
                       << "(bloco unicast de reqid " << p->reqid
                       << ") pois o fragmento 0 ainda não chegou!" << endl;
            else
                m_log << "[procpktfrag] Descartando fragmento " << num
                       << "(bloco multicast de reqid " << p->reqid
                       << ") pois o fragmento 0 ainda não chegou!" << endl;
            #endif

            //Linha abaixo é útil para se gerar gráfico de fragmentos
            //descartados ao into do tempo.
            #ifdef RIO_DEBUG2
            m_log << "DISCARTEDPACKAGE " << (int)time(NULL) << " "
                  << sizeof( RioPkt::pktfx ) << endl;
            #endif

            goto unlockret;
        }
        dp = rp->nb_blockp + rp->rq_fraglen0 + (num - 1) * rp->rq_fraglen;
        pktp += sizeof( RioPkt::pktfx );
        pktl -= sizeof( RioPkt::pktfx );
    }

    rp->rq_bits[ num ] = 1;
    if( rp->rq_fraghigh < num )
        rp->rq_fraghigh = num;

    if( dp + pktl > rp->nb_blockp + rp->nb_blockl )
    {
        /* frag outside of max block */
        err_overfrag++;

        #ifdef RIO_DEBUG2
        if( traffic == MULTICASTTRAFFIC && callback_transport )
        {
            m_log << "RioNeti - ack2 multicast - " << num << "/"
                   << rp->rq_fraghav << " bloco: " << current->GetPreqid()
                   << endl;
        }
        else
        {
            m_log << "RioNeti - ack2 unicast - " << num << "/"
                   << rp->rq_fraghav << " reqid: " << p->reqid << endl;
        }
        #endif

        goto checkack;
    }

    memcpy( dp, pktp, pktl );
    rp->rq_fraghav++;

    if( m_debug & DEBUG_FRAG )
    {
        m_log << "procpkt: hav " << rp->rq_fraghav << " max "
              << rp->rq_fragmax << endl;
    }

    if( rp->rq_fraghav >= rp->rq_fragmax )
    {
        // have whole block
        // ### should NOT delay local notification as delay
        // will add to request latency; however one trip
        // from procpkt (here) to completion rtn is ok.

        #ifdef RIO_DEBUG_EMUL
        RioRequest *Request = ( RioRequest * ) rp->nb_userparm;
        m_log << "[RioNeti] Whole Block (reqid " << rp->nb_reqid
               << ") " << Request->Block << " arrived and assembled" << endl;
        #endif

        rp->rq_needack = -1000; // is complete
        if( !rp->nb_sendack )
        {
            if( traffic == MULTICASTTRAFFIC && callback_transport )
            {
                //Último fragento do bloco current->GetPreqid() chegou.
                //Removendo este item da tabela reqid_table.
                reqid_table->Remove( current->GetPreqid() );
            }

            cnt_rcvfragack++;
            qComplete( rp, 0 );
        } // fim do if( !rp->nb_sendack )
    } // fim do if( rp->rq_fraghav >= rp->rq_fragmax )

checkack:

    if( rp->rq_needack <= 0 && !rp->nb_outrtn && rp->nb_sendack )
        iOutAddTop( rp, &iSendFragAck );

unlockret:
    HashMutexUnlock();

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpktfrag] Finish 3" << endl;
    #endif

    return;
}

void RioNeti::procpktfragack	(	char *	pktp,
		int	pktl
	)			[private]

Definition at line 4135 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpktfragack] Start" << endl;
    #endif

    int  seq;
    int  numhave;
    int  numhigh;
    int  numrec;
    u16 *dl;
    u16 *dx;
    int  listn;
    int  list0;

    RioPkt::pktfa *p = (RioPkt::pktfa *) pktp;
    HashMutexLock( "prcpkfrgack1" );
    NetBuf *rp = iHashFind( p->reqid );
    if( !rp )
    {
        HashMutexUnlock( "prcpkfrgack2" );
        SendRst( m_fraddr.sin_addr.s_addr, m_fraddr.sin_port, p->reqid, 0xe21f);

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - procpktfragack] Finish 1" << endl;
        #endif

        return;
    }
            
    #ifdef RIO_DEBUG2
    m_log << "[RioNeti - procpktack] NetBuf: "
          << "nb_reqid " << rp->nb_reqid
          << " nb_tiwhen " << rp->nb_tiwhen.tv_sec
          << " " << rp->nb_tiwhen.tv_usec
          << " rq_fragsh " << rp->rq_fragsh
          << " rq_fragburst " << rp->rq_fragburst
          << " rq_burstcnt " << rp->rq_burstcnt
          << " rq_fraglistn " << rp->rq_fraglistn
          << " nb_sendack " << rp->nb_sendack
          << " nb_hisreqid " << rp->nb_hisreqid
          << " nb_bufp type " << (int)((RioPkt::pktp *) rp->nb_bufp)->type
          << endl;
    #endif

    if( (unsigned)pktl < sizeof( RioPkt::pktfa ) )
    {
        err_pktsize++;
        goto unlockret;
    }

    // ### could check that netbuf found is for pending blocksend?
    seq     = ntohs( p->fragackseq );
    numhave = ntohs( p->fragnum );
    numhigh = ntohs( p->fraghigh );

    #ifdef RIO_DEBUG2
    m_log << " procpktfragack nb_reqid " << rp->nb_reqid
           << " seq " << seq
           << " qtde " << numhave
           << " high " << numhigh << endl;
    #endif

    if( m_debug & DEBUG_FRAG )
    {
        m_log << " procpktfragack ackseq " << seq << "  ackhave " << numhave
              << " ackhigh " << numhigh << endl;
        m_log << "\trq_fragackseq " << rp->rq_fragackseq << " rq_fraghav "
              << rp->rq_fraghav << " rq_fragburst " << rp->rq_fragburst << endl;
    }

    if( seq <= rp->rq_fragackseq )
        goto unlockret;        // dup or out of order fragack

    rp->rq_fragackseq = seq;
    cnt_rcvfragack++;

    if( rp->rq_fragmax <= numhave )
    {    // he has whole block
        if( m_debug & DEBUG_FRAG )
        {
            m_log << " fragack - complete! max " << rp->rq_fragmax << " have "
                  << numhave << endl;
        }
        qComplete( rp, 0 );
        goto unlockret;
    }

    numrec = numhave - rp->rq_fraghav;    // frags which left network
    // ### could I calc frags in network as # send - num received + num missing?
    rp->rq_burstcnt += numrec + 1;        // grow
    if( rp->rq_burstcnt > NetBuf::RQ_BURSTMAX )
        rp->rq_burstcnt = NetBuf::RQ_BURSTMAX;

    //    rp->rq_fragburst += 1;            // grow this a bit for retries
    rp->rq_fraghav = numhave;

    listn = rp->rq_fraglistn;
    list0 = rp->rq_fraglist[ 0 ];

    // save report of missing fragments if they haven't been sent recently
    dl = (u16 *) (pktp + sizeof(RioPkt::pktfa));
    dx = (u16 *) (pktp + pktl);
    for( rp->rq_fraglistn = 0; dl < dx; dl++ )
    {
        u16 xfrag = ntohs( *dl );
        if( rp->rq_fragackseq - rp->rq_bits[ xfrag ] > 2 )
        {
            if( rp->rq_fraglistn >= NetBuf::RQ_MAXACKLIST )
                break;
            rp->rq_fraglist[ rp->rq_fraglistn++ ] = xfrag;
        }
    }

    // if packets are reported lost then cut down burst size
    if( rp->rq_fraglistn != listn ||
        (listn > 0 && rp->rq_fraglist[0] != list0)
      )
    {
        cnt_rcvfragacknc++;        // new congestion
        rp->rq_burstcnt >>= 1;
        if( rp->rq_burstcnt < NetBuf::RQ_BURSTMIN )
            rp->rq_burstcnt = NetBuf::RQ_BURSTMIN;
    }

    // if not already queued to send more
    if( !rp->nb_outrtn )
    {
        if( !iSendFragNext( rp ) )
            iSendFrag( rp );
    }

unlockret:
    HashMutexUnlock( "prcpkfrgack3" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpktfragack] Finish 2" << endl;
    #endif

    return;
}

void RioNeti::procpktrst	(	char *	pktp,
		int	pktl
	)			[private]

Definition at line 3653 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpktrst] Start" << endl;
    #endif

    NetBuf *rp;

    RioPkt::pktp *p = (RioPkt::pktp *)pktp;

    if( (unsigned)pktl != sizeof( RioPkt::pktp ) )
    {
        err_pktsize++;

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - procpktrst] Finish 1" << endl;
        #endif

        return;
    }

    HashMutexLock( "prpktrst" );
    rp = iHashFindRst( m_fraddr.sin_addr.s_addr, m_fraddr.sin_port, p->reqid );

    if( rp == 0 )
        goto unlockret;
    // ### is this how to do auth chech on rst packet??
    if( !p->auth.checkauth( pktp, pktl, rp ) )
        goto unlockret;

    // ### should check if is sendblock first..
    if( rp->rq_fragsh >= rp->rq_fragmax )
    {
        qComplete( rp, 0 );
    }
    else
    {
        // the block could be canceled,
        // so don't abort just mark complete and go on
        qComplete( rp, ntohs( p->x2 ) );
    }

unlockret:
    HashMutexUnlock( "prpktrst" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - procpktrst] Finish 2" << endl;
    #endif

    return;
}

static void RioNeti::procretry

(

struct td4_tim *

)

[static, private]

void RioNeti::prtcnt

(

void

)

[private]

Definition at line 5418 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - prtcnt] Start" << endl;
    #endif

    m_log << " RioNeti counts --" << endl
          << "  cnt_sndpkt " << cnt_sndpkt << ", cnt_rcvpkt " << cnt_rcvpkt
          << ", cnt_retry " << cnt_retry << endl
          << "  cnt_rst1 " << cnt_rst1 << ", cnt_rst2 " << cnt_rst2 << endl
          << "  cnt_rcvfragack " << cnt_rcvfragack << ", cnt_rcvfragknc "
          << cnt_rcvfragacknc << endl
          << "  err_dupfrag " << err_dupfrag << ", err_overfrag "
          << err_overfrag << endl
          << "  err_pktsize " << err_pktsize << ", err_pktmagic "
          << err_pktmagic << ", err_pktnoreq " << err_pktnoreq << endl
          << "  err_pktcmd " << err_pktcmd << ", err_pktfmt " << err_pktfmt
          << endl;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - prtcnt] Finish" << endl;
    #endif
}

void RioNeti::prtHash

(

const char *

s

)

[private]

Definition at line 5387 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - prtHash] Start" << endl;
    #endif

    int     ix;
    NetBuf *rp;

    m_log << " prtHash: " << s << endl;
    for( ix = 0; ix < XM_REQNUM; ix++ )
    {
        rp = reqarray[ ix ];
        while( rp != NULL )
        {
            char print[256];
            sprintf( print,
                     "Hora: %d\t seq %5d\t%p nb_link %p reqid %d",
                     (unsigned int)rp->nb_frag0arrive, ix, rp,
                     rp->nb_link, (unsigned int)rp->nb_reqid );
            m_log << print << endl;
            rp = rp->nb_link;
        }
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - prtHash] Finish" << endl;
    #endif
}

void RioNeti::prttim

(

const char *

s

)

[private]

Definition at line 2698 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - prttim] Start" << endl;
    #endif

    NetBuf *tep, *p0;

    p0 = VIRTORG(xm_timeq, NetBuf, nb_tidq);
    char print[256];
    sprintf(print, " prttim: @ xm_timeq %p, f/l %p %p %s" ,
        p0, xm_timeq.linkf, xm_timeq.linkb, s);
    m_log << print << endl;

    for(tep = p0->nb_tidq.linkf; tep != p0; tep = tep->nb_tidq.linkf)
    {
        char print2[256];
        sprintf( print2,
                 "  %p te f/l %p %p sec/usec %8.8x %8.8x "
                 " rtn %p" ,
                 tep,
                 tep->nb_tidq.linkf,
                 tep->nb_tidq.linkb,
                 (unsigned int) tep->nb_tiwhen.tv_sec,
                 (unsigned int) tep->nb_tiwhen.tv_usec,
                 tep->nb_callback);
        m_log << print2 << endl;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - prttim] Finish" << endl;
    #endif
}

NetBuf * RioNeti::pSend	(	int	ipadr,
		int	port,
		int	reqid,
		call_type	type
	)			[private]

Definition at line 3036 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - pSend] Start" << endl;
    #endif

    NetBuf *nbp      = mbget();
    nbp->nb_toipaddr = ipadr;
    nbp->nb_toipport = port;
    nbp->rq_retry    = 5;
    nbp->nb_sendp    = nbp->nb_bufp;
    nbp->nb_datalm   = nbp->nb_bufp + nbp->nb_bufl;

    RioPkt::pktp *p = (RioPkt::pktp *) nbp->nb_bufp;

    p->type  = type;
    p->x1    = 0;
    p->x2    = 0;
    p->reqid = reqid;
    // ### do auth after whole packet is built in qSend
    // ###     p->auth.makeauth(nbp->nb_sendp, nbp->nb_sendl, nbp);

    nbp->nb_datap = nbp->nb_bufp + sizeof(RioPkt::pktp);

    iHashNew( nbp );
    // add my reqid after pktp
    *((u32 *) nbp->nb_datap) = nbp->nb_reqid;
    nbp->nb_datap += sizeof(u32);

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - pSend] Finish" << endl;
    #endif

    return nbp;
}

void RioNeti::qComplete	(	NetBuf *	nbp,
		int	result
	)			[private]

qComplete chama a CallBack do cliente indiretamente: seta vari�veis que a NetMgrThread fica analisando continuamente em um loop de forma que a NetMgrThread perceba que o bloco j� est� pronto para ser executado e, consequentemente, chame a CallBack do cliente.

Coment�rio antigo: queue to run " user" level completion routine (w/o lock held) // caller holds hash lock

Definition at line 3141 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - qComplete] Start" << endl;
    #endif

    // set completion code if not already set
    if( nbp->nb_result == ERROR_RIONETI )
    {
        nbp->nb_result = result;
    }

    //TODO: E da tabela multicast? Nao eh removido? Se nao, seria bom comentar
    //aqui o motivo.
    iHashRmv(nbp);
    iOutRmv(nbp);
    iTimeRmv(nbp);

    // add to end of completion queue
    nbp->nb_link      = 0;
    m_cmpltl->nb_link = nbp;
    m_cmpltl          = nbp;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - qComplete] Finish" << endl;
    #endif
}

void RioNeti::qSend

(

NetBuf *

nbp

)

[private]

Definition at line 3075 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - qSend] Start" << endl;
    #endif

    nbp->nb_sendl = nbp->nb_datap - nbp->nb_sendp;

    RioPkt::pktp *p = (RioPkt::pktp *) nbp->nb_sendp;

    p->auth.makeauth(nbp->nb_sendp, nbp->nb_sendl, nbp);

    gSend( nbp );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - qSend] Finish" << endl;
    #endif
}

void RioNeti::RequestMapping	(	int	ipaddr,
		int	port,
		int	server,
		callback_t	callback,
		void *	callbackparm
	)

RequestMapping faz uma requisicao a um outro objeto RioNeti, pedindo o mapeamento, isto e, o endereco IP e a porta visivel por este objeto.

O outro objeto esta executando em uma maquina com endereco IP e porta dados pelos parametros da funcao. Esta funcao deve ser chamada apos a inicializacao do socket, isto e, somente apos a funcao Start ter sido executada. A funcao de callback passada como parametro e chamada apos um mapeamento ter sido recebido. Nota: esta funcao foi baseada no codigo da funcao SendResult.

Parameters:

	ipaddr	endereco IP do objeto RioNeti.
	port	porta do objeto RioNeti.
	callback	funcao de callback a ser chamada quando a requisicao for completada com sucesso e um mapeamento for retornado.
	callbackparm	parametro passado quando a callback e chamada.

Definition at line 5972 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - RequestMapping] Start" << endl;
    #endif

    HashMutexLock( "requestmapping" );
    
    // Utilizamos o indice do servidor - 0 para o servidor e 1, 2, .... para
    // os storages - como reqid do pedido de mapeamento; isto permite
    // identificacao de duplicatas
    NetBuf *nbp = pSend( ipaddr, port, server, RioNeti::TYPE_SENDMAP );
    
    nbp->nb_usercall = callback;
    nbp->nb_userparm = callbackparm;

    nbp->nb_callback = &sendcmdcb; 
    nbp->rq_retry    = 3; // Numero de tentativas para o pedido do mapeamento.
    nbp->rq_retrytim = 1 << (TimeShift - 1);
    iTimeNew( nbp, nbp->rq_retrytim );

    // Inicializa os campos da estrutura com as informacoes sobre de quem 
    // pediremos o mapeamento. Esta estrutura sera usada ao recebermos as 
    // respostas, para podermos identificar o servidor do qual a resposta
    // se originou.
    
    m_MappingInfo[ server ].reqid = nbp->nb_reqid;  
    m_MappingInfo[ server ].IP = ipaddr;
    m_MappingInfo[ server ].port = port;
    // Novo campo para informar se o servidor esta ativo.
    m_MappingInfo[ server ].IsEnabled = false;
    
    #ifdef RIO_DEBUG2
    struct in_addr clientip;
    clientip.s_addr = ipaddr;
    m_log << " RioNeti : RequestMapping  ip addr " << inet_ntoa( clientip )
           << " port " << ntohs( port ) << " reqid " << nbp->nb_reqid << endl;
    #endif

    qSend( nbp );
    HashMutexUnlock( "requestmapping" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - RequestMapping] Finish" << endl;
    #endif
}

void RioNeti::restartreq

(

NetBuf *

)

[private]

void RioNeti::sendblockcb	(	NetBuf *	nbp,
		int	type,
		char *	cmdp,
		int	cmdl
	)			[static, private]

Definition at line 5256 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - sendblockcb] Start" << endl;
    #endif

    static int dbgcnt = 0;
    RioNeti *netiPtr = nbp->nb_rioneti;

    if( netiPtr->m_debug & DEBUG_DATA )
    {
        m_log << " sendblockcb: " << type << " reqid " << nbp->nb_reqid
              << " hisreqid " << nbp->nb_hisreqid << endl;
    }

    switch( (RioNeti::call_type)type )
    {
        case TYPE_RESULT:
            #ifdef RIO_DEBUG2
            m_log << "sendblockcb1 nbp->nb_result " << nbp->nb_result << endl;
            #endif

            netiPtr->qComplete( nbp, ntohl(*(u32 *)cmdp) );
            break;

        case TYPE_TIMEOUT:
            if( netiPtr->m_debug & DEBUG_TIMEOUT )
            {
                #ifdef RIO_DEBUG2
                m_log << " TIMEOUT: "  << (int *) nbp
                      << "  reqid "  << nbp->nb_reqid
                      << "  rq_fragsh "  << nbp->rq_fragsh
                      << "  rq_fragburst "  << nbp->rq_fragburst
                      << "  rq_burstcnt "  << nbp->rq_burstcnt
                      << " \n\trq_retryfrag "  << nbp->rq_retryfrag
                      << "  rq_fraghav "  << nbp->rq_fraghav
                      << "  rq_retry "  << nbp->rq_retry
                      << "  rq_retrytim "  << nbp->rq_retrytim
                      << "  rq_fragmax "  << nbp->rq_fragmax
                      << " \n\trq_fraglistn "  << nbp->rq_fraglistn
                      << "  list "  << nbp->rq_fraglist[0]
                      << "  "  << nbp->rq_fraglist[1]
                      << "  "  << nbp->rq_fraglist[2]
                      << "  "  << nbp->rq_fraglist[3]
                      << endl;
                #endif

                if( ++dbgcnt > 30 )
                {
                    dbgcnt = -1000000;
                }
            }
            if( nbp->rq_retryfrag == nbp->rq_fraghav )
            {
                // no progress, dcr retry count
                if( !netiPtr->iRetry( nbp ) )
                {
                    #ifdef RIO_DEBUG1
                    m_log << "[RioNeti - sendblockcb] Finish 1" << endl;
                    #endif

                    return;
                }
                // if no reported missing frags and all sent
                // then resend last frag
                if( nbp->rq_fraglistn == 0 &&
                    nbp->rq_fragsh == nbp->rq_fragmax
                  )
                {
                    nbp->rq_fragsh--;
                }
            }
            else
            {
                // made progress
                nbp->rq_retryfrag = nbp->rq_fraghav;
            }

            // if no fragments reported as received at all then
            // start over sending fragment 0
            if( nbp->rq_fraghav == 0 )
            {
                nbp->rq_fragsh    = 0;
                nbp->rq_fraglistn = 0;
                memset( nbp->rq_bits, 0, sizeof( nbp->rq_bits ) );
            }

            nbp->rq_fragburst >>= 1;
            if( nbp->rq_fragburst < 4 )
                nbp->rq_fragburst = 4;

            nbp->rq_burstcnt = nbp->rq_fragburst;

            #ifdef RIO_DEBUG2
            m_log << "sendblockcb fragburst = burstcnt = "<< nbp->rq_fragburst
                   << endl;
            #endif

            if( !netiPtr->iSendFragNext( nbp ) )
                netiPtr->iSendFrag( nbp );

            nbp->rq_retrytim <<= 1;
            netiPtr->iTimeNew( nbp, nbp->rq_retrytim );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - sendblockcb] Finish 2" << endl;
            #endif

            return;

        default:
            #ifdef RIO_DEBUG2
            m_log << "sendblockcb2 nbp->nb_result " << nbp->nb_result << endl;
            #endif

            // must be error
            netiPtr->qComplete( nbp, ERROR_RIONETI + 2 );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - sendblockcb] Finish 3" << endl;
            #endif

            return;
    } // fim do switch( (RioNeti::call_type)type )

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - sendblockcb] Finish 4" << endl;
    #endif
}

void RioNeti::SendCmd	(	int	ipadr,
		int	port,
		int	reqid,
		char *	cmdp,
		int	cmdl,
		callback_t	callback,
		void *	callbackparm
	)

SendCmd -- send a command to target ip/port multiple of these can be in progress to the same target.

The order of arrival at the target is NOT specified and they can be duplicated too (so one SendCmd can result in multiple ones being processed at the other side).

Definition at line 4741 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendCmd] Start" << endl;
    #endif

    char *endp;
    
    HashMutexLock( "sndcmd" );

    NetBuf *nbp = pSend( ipadr, port, reqid, RioNeti::TYPE_CMD);
    nbp->nb_usercall = callback;
    nbp->nb_userparm = callbackparm;

    endp = nbp->nb_datap + cmdl;

    // if cmd too int
    if( endp > nbp->nb_datalm )
            abort();

    memcpy( nbp->nb_datap, cmdp, cmdl );
    nbp->nb_datap += cmdl;

    nbp->nb_callback = &sendcmdcb;
    nbp->rq_retry    = 5;
    nbp->rq_retrytim = 1 << (TimeShift - 3);

    iTimeNew( nbp, nbp->rq_retrytim );
    qSend( nbp );
    HashMutexUnlock( "sndcmd" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendCmd] Finish" << endl;
    #endif
}

void RioNeti::sendcmdcb	(	NetBuf *	nbp,
		int	type,
		char *	cmdp,
		int	cmdl
	)			[static, private]

Definition at line 4784 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - sendcmdcb] Start" << endl;
    #endif

    RioNeti *netiPtr = nbp->nb_rioneti;

    if( netiPtr->m_debug & DEBUG_CMDS )
        m_log << " sendcmdcb " << type << " reqid " << nbp->nb_reqid << endl;

    switch( (call_type)type )
    {
        case TYPE_ACK:
        case TYPE_MAPACK: // Nova opcao para finalizar o tratamento do novo 
                          // tipo de ACK usado para enviar o mapeamento. O
                          // tratamento deste ACK e identico ao do ACK normal.
            netiPtr->qComplete( nbp, 0 );
            break;

        case TYPE_RESULT:

            #ifdef RIO_DEBUG2
            m_log << "sendcmdcb1 nbp->nb_result " << nbp->nb_result << endl;
            #endif

            netiPtr->qComplete( nbp, ntohl( *(u32 *)cmdp ) );
            break;

        case TYPE_TIMEOUT:
            if( !netiPtr->iRetry( nbp ) )
            {
                #ifdef RIO_DEBUG1
                m_log << "[RioNeti - sendcmdcb] Finish 1" << endl;
                #endif

                return;
            }

            nbp->rq_retrytim <<= 1;
            netiPtr->iTimeNew( nbp, nbp->rq_retrytim );
            netiPtr->qSend( nbp );
            break;

        default:
            // must be error
            #ifdef RIO_DEBUG2
            m_log << "sendcmdcb2 nbp->nb_result " << nbp->nb_result << endl;
            #endif

            netiPtr->qComplete( nbp, ERROR_RIONETI + 3 );
            break;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - sendcmdcb] Finish 2" << endl;
    #endif
}

void RioNeti::SendData	(	int	ipadr,
		int	port,
		int	reqid,
		char *	bufadr,
		int	buflen,
		callback_t	callback,
		void *	callbackparm,
		int	StreamTraffic,
		unsigned int	VideoRate = 0,
		unsigned int *	sendreqid = NULL
	)

Definition at line 5122 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendData] Start" << endl;
    #endif
    
    NetBuf *nbp;

    #ifdef RIO_DEBUG2
    m_log << "RioNeti - SendData:"
           << " port " << ntohs( port )
           << " reqid " << reqid
           << " buflen " << buflen
           << " StreamTraffic " << StreamTraffic << endl;
    #endif

    nbp = mbget();
    nbp->nb_blockp     = bufadr;
    nbp->nb_blockl     = buflen;
    nbp->nb_toipaddr   = ip;
    nbp->nb_toipport   = port;
    nbp->nb_usercall   = callback;
    nbp->nb_userparm   = callbackparm;
    nbp->rq_fragackseq = 0;
    nbp->rq_fraghav    = 0;
    memset( nbp->rq_bits, 0, sizeof( nbp->rq_bits ) );

    nbp->rq_fraglistn = 0;
    
    // Inicializa o campo do objeto NetBuf que define o tempo de atualizacao
    // dos creditos (este campo nao e usado pela implementacao do cliente e do
    // servidor de despacho). 
    
    if( ( m_StreamControl != NULL ) && ( VideoRate != 0ull ) ) 
    {
        // Determina o tempo entre as atualizacoes de creditos, e o armazena
        // em TimeBetweenCredits. Este tempo e calculado a partir da taxa de
        // transferencia da rede dada por NetworkRate (network rate) e do
        // tamanho de um pacote enviado por um NetBuf.
        unsigned long long int VideoRateFS;
        // Primeiramente computamos a taxa de transferencia em
        // bytes/segundo.
        VideoRateFS = (( unsigned long long int ) VideoRate ) * 128ull;
        // Converte a taxa para Fragmentos/segundo.
        VideoRateFS = VideoRateFS / ( ( unsigned long long int ) FRAGMENTSIZE );
        // Computa o tempo de envio de dois NetBuf de um mesmo cliente. Por 
        // enquanto, estes parametros serao fixos. 
        nbp->nb_timebetweencredits = 1000000ull / VideoRateFS;  
    } 
    // Added to fix the bug: Storage used to stop
    // (was in loop) because the structure was not correct.
    // concorrency problem.
    HashMutexLock( "snddata1" );

    iHashNew( nbp );
    
    // Se sendreqid for diferente de NULL, entao armazenamos o reqid de nbp em
    // sendreqid.
    
    if( sendreqid != NULL )
        *sendreqid = nbp->nb_reqid;

    nbp->nb_hisreqid = reqid;
    nbp->nb_callback = &sendblockcb;
    nbp->rq_fragburst = NetBuf::RQ_BURSTSTART;
    nbp->rq_fragsh    = 0;

    nbp->rq_maxpktl = m_maxpktl;

    nbp->rq_fraglen  = nbp->rq_maxpktl
        - (iphdrlen + udphdrlen + sizeof( RioPkt::pktfx ));
    nbp->rq_fraglen0 = nbp->rq_maxpktl
        - (iphdrlen + udphdrlen + sizeof( RioPkt::pktf0 ));

    nbp->rq_fragmax = 1 +
        ((nbp->nb_blockl - nbp->rq_fraglen0 + nbp->rq_fraglen - 1)
            / nbp->rq_fraglen);

    #ifdef RIO_DEBUG2
    struct in_addr clientip;
    clientip.s_addr = ip;
    m_log << " RioNeti : SendData  ip addr " << inet_ntoa(clientip)
           << " port " << htons( port )
           << " buflen " << buflen
           << " clientreqid " << reqid
           << " reqid " << nbp->nb_reqid<< endl;
    m_log << " nbp->rq_fragmax "<< nbp->rq_fragmax
           << " nbp->rq_fraglen0 " << nbp->rq_fraglen0
           << " nbp->rq_fraglen  " << nbp->rq_fraglen << endl;
    #endif

    if( StreamTraffic != 3 )
        nbp->nb_sendack = 1;
    else  /* StreamTraffic */
        nbp->nb_sendack = 0;

    //not send ack
    if( nbp->nb_sendack != 0 )
    {
        nbp->rq_retryfrag = 0;
        nbp->rq_retry     = 5;
        nbp->rq_retrytim  = 1 << (TimeShift - 1);
    }
    else
    {
        nbp->rq_retry = 0;
    }

    nbp->rq_burstcnt = nbp->rq_fragburst;
    if( !iSendFragNext( nbp ) )
        iSendFrag( nbp );

    /*not send ack*/
    if( nbp->nb_sendack != 0 )
    {
        iTimeNew( nbp, nbp->rq_retrytim );
    }
    else 
    {
        //(*nbp->nb_usercall)(nbp->nb_userparm, 0);
        qComplete( nbp, 0 );
    }

    HashMutexUnlock( "snddata1" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendData] Finish" << endl;
    #endif
}

void RioNeti::SendResult	(	int	ipadr,
		int	port,
		int	reqid,
		int	result,
		callback_t	callback,
		void *	callbackparm
	)

Definition at line 4853 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendResult] Start" << endl;
    #endif

    HashMutexLock( "sndresul" );

    NetBuf *nbp = pSend( ipadr, port, reqid, RioNeti::TYPE_RESULT );
    nbp->nb_usercall = callback;
    nbp->nb_userparm = callbackparm;

    *((u32 *)nbp->nb_datap) = htonl( result );
    nbp->nb_datap += sizeof( u32 );

    nbp->nb_callback = &sendcmdcb;

    nbp->rq_retry    = 5;
    nbp->rq_retrytim = 1 << (TimeShift - 3);
    iTimeNew( nbp, nbp->rq_retrytim );

    #ifdef RIO_DEBUG2
    struct in_addr clientip;
    clientip.s_addr = ipadr;
    m_log << " RioNeti : SendResult  ip addr " << inet_ntoa( clientip )
           << " port " << ntohs( port ) << " reqid " << reqid << endl;
    #endif

    qSend( nbp );
    HashMutexUnlock( "sndresul" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendResult] Finish" << endl;
    #endif
}

void RioNeti::SendRst	(	int	ipaddr,
		int	port,
		int	reqid,
		int	result
	)

Esta funcao, que antes era private, agora passou a ser public para permitir que enviemos um erro para cancelar um pedido pendende.

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.

Parameters:

	ipaddr	endereco IP para onde deveremos enviar o codigo de erro.
	port	porta para onde deveremos enviar o codigo de erro.
	reqid	identificacao do NetBuf que desejamos enviar o erro.
	result	codigo de erro a ser enviado.

Definition at line 3582 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendRst] Start" << endl;
    #endif

    NetBuf *nbp;
    RioPkt::pktp *p;

    HashMutexLock( "sendrst1" ); //for count too
    cnt_rst1++;

    if( m_debug & DEBUG_CMDS)
    {
        char print[256];
        sprintf( print, " SendRst: %8.8x %8.8x %8.8x %8.8x" ,
                 (unsigned)ipaddr, (unsigned)port, (unsigned)reqid,
                 (unsigned)result );
        m_log << print << endl;
    }

    // avoid sending duplicate rst if recently sent one to same target
    if( xm_now.tv_sec == xm_rstsec)
    {
        if( xm_rstip == ipaddr && xm_rstport == port
            && xm_rstreqid == reqid)
        {
            HashMutexUnlock( "sendrst2" );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - SendRst] Finish 1" << endl;
            #endif

            return;
        }
    }

    xm_rstsec        = xm_now.tv_sec;
    xm_rstip         = ipaddr;
    xm_rstport       = port;
    xm_rstreqid      = reqid;

    nbp              = mbget();
    nbp->nb_toipaddr = ipaddr;
    nbp->nb_toipport = port;
    nbp->nb_sendp    = nbp->nb_buf;
    p = (RioPkt::pktp *) nbp->nb_sendp;
    p->type          = TYPE_RST;
    p->x1            = 0;
    p->x2            = htons((u16) result);
    p->reqid         = reqid;
    nbp->nb_sendl    = sizeof(RioPkt::pktp);
    p->auth.makeauth(nbp->nb_sendp, nbp->nb_sendl, nbp);

    fSend(nbp);
    cnt_rst2++;
    HashMutexUnlock( "sendrst3" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SendRst] Finish 2" << endl;
    #endif
}

void RioNeti::SetCmdProc	(	cmdcallback_t	cmdproc,
		void *	cmdparm
	)

Este m�todo n�o est� sendo usado em lugar nenhum do c�digo.

Definition at line 1761 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetCmdProc] Start" << endl;
    #endif

    m_cmdproc = cmdproc;
    m_cmdparm = cmdparm;

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetCmdProc] Finish" << endl;
    #endif
}

void RioNeti::setLogRotation

(

CLogRotation *

LogRotation

)

Funcao para definir o objeto (do tipo CLogRotation) a ser usado para armazenas as estatisticas de envio de pacotes.

Parameters:

LogRotation

ponteiro para um objeto do tipo CLogRotation.

Definition at line 6067 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - setLogRotation] Single" << endl;
    #endif

    // Define o objeto (do tipo CLogRotation) que armazena os logs dos pacotes
    // enviados.
    m_LogRotation = LogRotation;
}

void RioNeti::SetLoopBack	(	int	socket,
		char	loop
	)			[private]

Definition at line 1454 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetLoopBack] Start" << endl;
    #endif

    if( setsockopt( socket, IPPROTO_IP, IP_MULTICAST_LOOP,
        ( char*) &loop, sizeof( loop )) == -1 )
    {
        m_log << " SetLoopBack Error " << endl;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetLoopBack] Finish" << endl;
    #endif
}

bool RioNeti::SetMulticastSocket	(	unsigned short	multicastport,
		char *	multicast_addr,
		void *	callback = 0,
		BufferStream *	buffer_stream = 0,
		int	enable_join = 1
	)

SetMulticastSocket cria um novo socket multicast com as informa��es recebidas nos par�metros multicastport e multicast_addr.

Para isto, SetMulticastSocket varre a lista multicastInfo procurando uma posi��o livre para criar o novo socket. Se uma posi��o livre n�o for encontrada, este m�todo n�o cria o novo socket e retorna false. Este m�todo � chamado na CommMulticastStream no momento em que recebe uma mensagem do tipo MSGCODE_IP, que informa ao cliente que ele deve passar a escutar um determinado fluxo multicast (JOIN_THIS).

Parameters:

	multicastport	n�mero da porta multicast a ser associada ao socket que ser� criado.
	multicast_addr	ip multicast a ser associada ao socket que ser� criado.
	callback	ponteiro para a fun��o de callback do cliente a ser executada quando o bloco chega. Por default � igual a NULL.
	buffer_stream	ponteiro para a buffer_stream, respons�vel pela armazenagem e acesso aos blocos da stream de v�deo gravados no disco. Por default � igual a NULL. Por default: *callback = 0, *buffer_stream = 0 e enable_join = 1.

Definition at line 900 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetMulticastSocket] Start" << endl;
    #endif

    // Associate socket to multicast address
    int sockIndex = -1;
    int aux       = 1;
    int rc;

    SocketMulticastLock( "setsocklk" );

    #ifdef RIO_DEBUG2
    m_log << "[SetMulticastSocket] status dos sockets: 0/1 = "
           << multicastInfo[0].isConnected << "/"
           << multicastInfo[1].isConnected << endl;
    #endif

    //procurando uma posição livre na matriz multicastInfo para abrir novo
    //socket multicast
    for( int i = 0; i < MULTICAST_SOCKETS; i++ )
    {
        //Este loop procura uma posição livre em multicastInfo para setar o
        //novo socket, mas se este socket já estiver setado, não devo ocupar
        //duas posições em multicastInfo para o mesmo socket.
        //Este tipo de requisição repetida pode acontecer quando o cliente
        //interage mas acaba caindo no mesmo grupo de origem. Neste caso, a PL,
        //ainda assim, envia o MSGCODE_IP, para que o cliente não trave
        //eternamente no pthread_cond_wait(...,&multicastMutex ).

        if( ( multicastInfo[i].isConnected == true ) &&
            ( multicastInfo[i].myaddr_in.sin_port == htons( multicastport ) )
          )
        {
            #ifdef RIO_DEBUG2
            m_log << "[RioNeti] SetMulticastSocket foi chamada para setar "
                   << "porta " << multicastport << " que já estava setada. "
                   << "Pedido será ignorado." << endl;
            #endif

            SocketMulticastUnlock( "setsockulk1" );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - SetMulticastSocket] Finish 1" << endl;
            #endif

            return false;
        }
        else if( ( multicastInfo[i].isConnected == false ) &&
                 ( sockIndex == -1 ) //pegar a primeira posição livre
               )
        {
            sockIndex = i;
        }
    } // fim do for( int i = 0; i < MULTICAST_SOCKETS; i++ )

    if( sockIndex == -1 )
    {
        m_log << "[RioNeti] SetMulticastSocket ERROR: máximo de conexões "
               << "multicast alcançado. Não é possível iniciar uma nova conexão."
               << endl;

        SocketMulticastUnlock( "setsockulk2" );

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - SetMulticastSocket] Finish 2" << endl;
        #endif

        return false;
    }

    this->callback_transport = (RioCallBackTransport *) callback;
    this->callback           = ((RioCallBackTransport *) callback)->callback;
    this->buffer_stream      = buffer_stream;

    multicastInfo[sockIndex].myaddr_in.sin_family      = AF_INET;
    multicastInfo[sockIndex].myaddr_in.sin_port        = htons( multicastport );
    multicastInfo[sockIndex].myaddr_in.sin_addr.s_addr = htonl( INADDR_ANY );

    // Server doesn't set multicast socket
    if( enable_join )
    {
        CreateMulticastSocket( sockIndex );

        mucksockopt( multicastInfo[sockIndex].socket );

        if( setsockopt( multicastInfo[sockIndex].socket, SOL_SOCKET,
                        SO_REUSEADDR, (char*)&aux, sizeof(aux)) == -1 )
        {
            m_log << " Reuseaddr error " << endl;
        }

        SetTTLValue( multicastInfo[sockIndex].socket, 1 );
        SetLoopBack( multicastInfo[sockIndex].socket, 1 );

        if( bind( multicastInfo[sockIndex].socket,
                  (struct sockaddr *) &(multicastInfo[sockIndex].myaddr_in),
                  sizeof(multicastInfo[sockIndex].myaddr_in)) == -1 )
        {
            Rioperror( "[RioNeti SetMulticastSocket Bind]" );
            multicastInfo[sockIndex].socket = -1;
        }

        int i = 1;
        rc = ioctl( multicastInfo[sockIndex].socket, FIONBIO, &i );
        if( rc )
        {
            Rioperror( "ioctl FIONBIO failed" );

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - SetMulticastSocket] Finish 3" << endl;
            #endif

            exit( 1 );
        }

        JoinGroup( sockIndex, multicast_addr );
    } // fim do if( enable_join )

    SocketMulticastUnlock( "setsockulk" );

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetMulticastSocket] Finish 4" << endl;
    #endif

    return true;
}

void RioNeti::SetTTLValue	(	int	socket,
		char	ttl
	)			[private]

Definition at line 1436 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetTTLValue] Start" << endl;
    #endif

    if( setsockopt( socket, IPPROTO_IP, IP_MULTICAST_TTL,
        ( char*) &ttl, sizeof( ttl )) == -1 )
    {
       m_log << " SetTTLValue Error " << endl;
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - SetTTLValue] Finish" << endl;
    #endif
}

void RioNeti::SocketMulticastLock

(

string

msg = ""

)

[private]

SocketMulticastLock trava o mutex socketMulticastMutex.

Parameters:

msg

� usado apenas no modo RIO_DEBUG2 para facilitar depura��es de clientes travados em mutex's.

Definition at line 5706 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG2
    if( msg.length() )
        m_log << "[SocketMulticastLock] " << msg << "... " << endl;
    #endif

    pthread_mutex_lock( &socketMulticastMutex );

    #ifdef RIO_DEBUG2
    if( msg.length() )
        m_log << "..." << msg << " OK!" << endl;
    #endif
}

void RioNeti::SocketMulticastUnlock

(

string

msg = ""

)

[private]

SocketMulticastUnlock destrava o mutex socketMulticastMutex.

Parameters:

msg

� usado apenas no modo RIO_DEBUG2 para facilitar depura��es de clientes travados em mutex's.

Definition at line 5721 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG2
    if( msg.length() )
        m_log << "[SocketMulticastUnlock] " << msg << endl;
    #endif

    pthread_mutex_unlock( &socketMulticastMutex );
}

int RioNeti::Start	(	int	port,
		int	maxdiskl,
		int	maxpktl,
		unsigned int	MaxClientsCredits,
		unsigned int	MaxNetworkCredits,
		unsigned int	NetworkRate
	)

Definition at line 389 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioNeti - Start] Start" << endl;
    #endif

    //log definition
    #ifdef RIO_DEBUG_FILE
    if( RioNetiLogPath == NULL )
    {
        char tmpName[256];
        char tmpDomain[256];
        gethostname( tmpName, 255 );
        getdomainname( tmpDomain, 255 );
        string file;
        if( serverInstance )
        {
            int myPort = ntohs( port );
            if( myPort == STORAGESERVERUDPPORT )
                file = "RIOStorageEmul_";
            else if( myPort == RIOSERVERUDPPORT )
                file = "RIOServerEmul_";
        }
        else
        {
            char tmpPid[ 20 ]; // Tamanho de um inteiro de 64 bits (caso o
                               // rio seja compilado em uma maquina cujo int
                               // e de 64 bits).
            pid_t myPid;
            myPid = getpid();
            sprintf( tmpPid, "%d", ( int ) myPid );                     
            file = "RIOClientEmul_";
            file += tmpPid;
            file += "_";
        }

        file += tmpName;
        if( strstr( tmpName, tmpDomain ) == NULL ) 
        {
            file += ".";
            file += tmpDomain;
        }
        file += ".log";
    
        m_log.open( file.c_str() );
    }
    else
        m_log.open( RioNetiLogPath );
    #endif

    int       rc;
    struct    sockaddr_in wk_addr; /* work address (for my bind) */
    pthread_attr_t attribMonitor;
    pthread_attr_t attribNetMgr;

    pthread_attr_init( &attribMonitor );
    pthread_attr_init( &attribNetMgr );
    pthread_attr_setstacksize( &attribMonitor, 2*PTHREAD_STACK_MIN );
    pthread_attr_setstacksize( &attribNetMgr,  2*PTHREAD_STACK_MIN );

    #ifdef WINDOWS
        // Windows implementation
        u_long FAR i;
        DWORD    THID;
    #else
        // Linux implementation
        int i;
    #endif

    if( !m_threadstop )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - Start] Finish 1" << endl;
        #endif

        return -1;    //  already started
    }

    // set debugging flags based on RIONETI_DEBUG environment variable
    m_debug = 0;
    char *envdbgp = getenv( " RIONETI_DEBUG" );
    if( envdbgp )
    {
        m_debug = atoi( envdbgp );
        if( m_debug )
        {
            m_log << " RioNeti m_debug " << m_debug << endl;
        }
    }

    i = 1000;
    envdbgp = getenv( " RIONETI_TRACEL" );
    if( envdbgp )
    {
        i = atoi( envdbgp );
        if( i < 1000 || i > 10000000 )
            i = 5000;
        if( m_debug )
            m_log << " RioNeti " << i << " trace entries" << endl;
    }

    m_ipaddr   = findNetInterface();
    m_ipport   = port;
    m_maxdiskl = maxdiskl;
    m_maxpktl  = maxpktl;

    #ifdef WINDOWS
    // Windows implementation
    if( m_debug & DEBUG_MISC )
    {
        int pktdatal = m_maxpktl - (iphdrlen + udphdrlen);
        int fraglen  = pktdatal - sizeof(RioPkt::pktfx);
        int fraglen0 = pktdatal - sizeof(RioPkt::pktf0);
        m_log << "m_maxpktl " << maxpktl << " pktdatal " << pktdatal
              << " fraglen " << fraglen << " fraglen0 " << fraglen0 << endl;

        m_log << "sizeof(RioPkt::pktp) " << sizeof(RioPkt::pktp)
              << " sizeof(RioPkt::pktf0) " << sizeof(RioPkt::pktf0) << endl;
        m_log << "sizeof(RioPkt::pktfx) " << sizeof(RioPkt::pktfx)
              << " sizeof(RioPkt::pktfa) " << sizeof(RioPkt::pktfa) << endl;
    }
    #else
    // Linux implementation
       #ifdef RIO_DEBUG2
        int pktdatal = m_maxpktl - (iphdrlen + udphdrlen);
        int fraglen  = pktdatal - sizeof(RioPkt::pktfx);
        int fraglen0 = pktdatal - sizeof(RioPkt::pktf0);
        m_log << "m_maxpktl " << maxpktl << " pktdatal " << pktdatal
              << " fraglen " << fraglen << " fraglen0 " << fraglen0 << endl;

        m_log << "sizeof(RioPkt::pktp) " << sizeof(RioPkt::pktp)
              << " sizeof(RioPkt::pktf0) " << sizeof(RioPkt::pktf0) << endl;
        m_log << "sizeof(RioPkt::pktfx) " << sizeof(RioPkt::pktfx)
              << " sizeof(RioPkt::pktfa) " << sizeof(RioPkt::pktfa) << endl;
       #endif
    #endif

    // Cria o objeto da classe CStreamControl antes de criar os objetos NetBuf
    // e o socket, para garantir que asthreads da classe CStreamControl ja 
    // terao sido criadas quando a thread principal de controle for criada. 
    // Isso somente sera feito se MaxClientsCredits, MaxNetworkCredits e 
    // TimeBetweenCredits forem todos diferente de 0.
    if( ( MaxClientsCredits != 0 ) && ( MaxNetworkCredits != 0 ) && 
        ( NetworkRate != 0 ) ) {
        // Cria o objeto m_StreamControl usado para controlar o fluxo de
        // fragmentos para os clientes. 
        m_StreamControl = new CStreamControl;
        if( m_StreamControl == NULL ) {
            Rioperror( "creation of StreamControl failed ");

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - Start] Finish 2" << endl;
            #endif
        
            exit( -1 );

        }
        // Determina o tempo entre as atualizacoes de creditos, e o armazena
        // em TimeBetweenCredits. Este tempo e calculado a partir da taxa de
        // transferencia da rede dada por NetworkRate (network rate) e do
        // tamanho de um pacote enviado por um NetBuf.
        unsigned long long int NetworkRateFS, TimeBetweenCredits;
        // Primeiramente computamos a taxa de transferencia em
        // bytes/segundo.
        NetworkRateFS = ( ( unsigned long long int ) NetworkRate ) * 131072ull;
        // Converte a taxa para NetBufs/segundo.
        NetworkRateFS = NetworkRateFS / ( ( unsigned long long int ) FRAGMENTSIZE );
        // Obtem o tempo de envio (em microsegundos) entre dois NetBuf
        // consecutivos. Como o objeto m_StreamControl envia objetos NetBuf de
        // acordo com os creditos, o valor de TimeBetweenCredits sera
        // exatamente este tempo entre os envios.
        TimeBetweenCredits = 1000000ull / NetworkRateFS;  
        // Inicializa a classe de controle do fluxo.
        if( m_StreamControl->Start( this, MaxClientsCredits, MaxNetworkCredits,
                                    TimeBetweenCredits ) != ERROR_NO_RIO_ERROR )
        {
            Rioperror( "start of StreamControl failed ");

            #ifdef RIO_DEBUG1
            m_log << "[RioNeti - Start] Finish 3" << endl;
            #endif
        
            exit( -1 );
        }
    }

    /* init memory block areas */
    mbinit( 10 );

    rc = socket( AF_INET, SOCK_DGRAM, 0 );
    if( rc < 0 )
    {
        Rioperror( "socket called failed" );

        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - Start] Finish 4" << endl;
        #endif

        exit( 1 );
    }
    
    m_sock = rc;        /* now have socket */

    // Faz com que o socket seja exclusivo do processo, e nao seja passado 
    // para um outro processo criado pelo processo que abriu o socket.
    if( fcntl( m_sock, F_SETFD, FD_CLOEXEC ) < 0 )
    {
        Rioperror( "fcntl called failed" );

        #ifdef RIO_DEBUG1
        m_log << "### [RioNeti - Start] Finish 5" << endl;
        #endif

        exit( 1 );
    }

    if( m_debug & DEBUG_MISC )
        m_log << " m_sock " << m_sock << endl;

    memset( &wk_addr, 0, sizeof( wk_addr ) );

    wk_addr.sin_family      = AF_INET;
    wk_addr.sin_addr.s_addr = INADDR_ANY; // any address
    wk_addr.sin_port        = m_ipport;
    if( bind( m_sock, (struct sockaddr *) &wk_addr,sizeof( wk_addr )) < 0 )
    {
        Rioperror( "bind called failed" );

        #ifdef RIO_DEBUG1
        m_log << "### [RioNeti - Start] Finish 6" << endl;
        #endif

        exit( 1 );
    }

    // SGI/IRIX doesn't have socklen_t and wants int (not unsigned int)
    #ifdef _SGI_SOURCE
    #define socklen_t int
    #endif

    #ifdef WINDOWS
    // Windows implementation
        int wkl = sizeof( myAddress );
    #else
    // Linux implementation
        socklen_t wkl = sizeof( myAddress );
    #endif

    if( getsockname( m_sock, (struct sockaddr *)&myAddress, &wkl ) != 0 )
    {
        Rioperror( "getsockname failed" );

        #ifdef RIO_DEBUG1
        m_log << "### [RioNeti - Start] Finish 7" << endl;
        #endif

        exit(1);
    }

    if( m_debug & DEBUG_MISC )
    {
        m_log << " wk socket: " << inet_ntoa( myAddress.sin_addr ) << ":"
              << ntohs( myAddress.sin_port ) << endl;
    }

    m_ipport = myAddress.sin_port;

    // Inicializa as variaveis usadas pela implementacao que permite clientes
    // atras de NAT. Por default, supomos que o cliente nao esta atras de NAT,
    // e inicializamos a lista de mapeamentos somente com o IP e a porta usado
    // na maquina em que o cliente esta executando, e inicializamos a flag
    // que indica se o cliente esta ou nao atras de NAT como false.
    m_behindnat = false;
    m_ipaddrmap = &m_ipaddr;
    m_ipportmap = &m_ipport;

    // muck with setsockopt SO_SNDBUF and SO_RCVBUF
    mucksockopt( m_sock );

    // start off mini-dispatcher

    #ifdef WINDOWS
    // Windows implementation
    GetSystemTime( &pSystemTime );
    xm_now.tv_sec  = pSystemTime.wSecond;
    xm_now.tv_usec = pSystemTime.wMilliseconds;
    #else
    // Linux implementation
    gettimeofday( &xm_now, NULL );
    #endif

    FD_ZERO( &readfds );
    FD_ZERO( &writefds );

    /* almost allways zero (!=0 means error occurred) */
    writefdsp = 0;

    // --- set socket to non-blocking
    //    This makes socket calls which would block an error so they can be
    //    fixed (it's better to avoid the call then get the block errno.)

    i = 1;

    #ifdef WINDOWS
    // Windows implementation
    rc = ioctlsocket(m_sock, FIONBIO, &i);
    if( rc )
    {
        Rioperror( "ioctlsocket FIONBIO failed");

        #ifdef RIO_DEBUG1
        m_log << "### [RioNeti - Start] Finish 8" << endl;
        #endif

        exit( 1 );
    }
    #else
    // Linux implementation
    rc = ioctl( m_sock, FIONBIO, &i );
    if( rc )
    {
        Rioperror( "ioctl FIONBIO failed" );

        #ifdef RIO_DEBUG1
        m_log << "### [RioNeti - Start] Finish 9" << endl;
        #endif

        exit( 1 );
    }
    #endif

    m_threadstop = 0;

    //Apenas o servidor precisa criar este socket abaixo. O cliente já o faz
    //sempre que chama SetMulticastSocket.
    if( serverInstance )
    {
        SocketMulticastLock( "servlock" );
        CreateMulticastSocket( 0 );
        SocketMulticastUnlock( "servulck" );
    }

    #ifdef WINDOWS
    // Windows implementation
    if( (m_thread = CreateThread( NULL, 0,
                                  (PTHREAD_START_ROUTINE )NetMgrThreadEp,
                                  (void *) this,0, &THID)) == NULL)
    {
        m_threadstop = 1;

        #ifdef RIO_DEBUG1
        m_log << "### [RioNeti - Start] Finish 11" << endl;
        #endif

        exit( 1 );
    }
    #else
    // Linux implementation
    if( pthread_create( &m_thread, &attribNetMgr, &NetMgrThreadEp,
                        (void *) this ) )
    {
        m_threadstop = 1;
        Rioperror( "pthread_create failed" );

        #ifdef RIO_DEBUG1
        m_log << "### [RioNeti - Start] Finish 12" << endl;
        #endif

        exit( 1 );
    }
    #endif

    #ifdef RIO_DEBUG1
    m_log << "### [RioNeti - Start] Finish 13" << endl;
    #endif

    return 0;
}

int RioNeti::Stop

(

void

)

Definition at line 1610 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - Stop] Start" << endl;
    #endif

    NetBuf *nbp;

    if( m_threadstop )
    {
        #ifdef RIO_DEBUG1
        m_log << "[RioNeti - Stop] Finish 1" << endl;
        #endif

        return 0;    // already stopped (or not started)
    }

    m_threadstop = 1;

    // send packet to myself to get thread to wake up right now (only if the 
    // NetMgrThread was created).
    if( m_thread != 0 )
    {
        #ifdef RIO_DEBUG2
        m_log << "RioNeti::Stop enviando a mensagem para parar a thread " 
              << "NetMgrThread" << endl;
        #endif
        
        HashMutexLock( "stop" );
        nbp              = mbget();
        nbp->nb_toipaddr = m_ipaddr;
        nbp->nb_toipport = m_ipport;
        memset( nbp->nb_buf, 0, 16 ); // invalid auth field
        nbp->nb_sendp    = nbp->nb_buf;
        nbp->nb_sendl    = 16;
        fSend( nbp );
        HashMutexUnlock( "stop" );
    }

    #ifdef WINDOWS
        // Windows implementation
        WaitForSingleObject(m_thread,INFINITE);
        //Verificar função....
        closesocket(m_sock);
    #else
        // Linux implementation
        // Somente se junta se a thread NetMgrThread foi criada. Ela nao sera
        // criada se ocorrer algum erro ao inicializar o TCP. 
        if( m_thread != 0 ) 
        {
            #ifdef RIO_DEBUG2
            m_log << "[RioNeti - Stop] Aguardando pthread_join..." << endl;
            #endif

            pthread_join( m_thread, NULL );

            #ifdef RIO_DEBUG2
            m_log << "[RioNeti - Stop] Joined!!!" << endl;
            #endif
        }
        
        // Cancela a thread que envia as mensagens Fake, se uma thread foi
        // criada.
        
        if( m_threadmap != 0 )
            pthread_cancel( m_threadmap );

        close( m_sock );
    #endif

    if( m_debug & DEBUG_CNT )
    {
        prtcnt();
    }

    // Para o objeto de controle de fluxo.
    if( m_StreamControl != NULL )
        m_StreamControl->Stop();

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - Stop] Finish 2" << endl;
    #endif

    return 0;
}

bool RioNeti::thereAreFragments

(

RioBlock

block

)

thereAreFragments verifica se existem fragmentos do bloco block_id e retorna true caso encontre algum fragmento para este bloco ou false caso contr�rio.

Parameters:

	block_id	indica o bloco que se quer recuperar os fragmentos.
	traffic	indica se o bloco foi requisitado em um pedido unicast ou multicast. Dependendo da origem do pedido, o bloco � recuperado de uma ou outra forma.

Returns:

retorna true caso encontre algum fragmento para o bloco block_id ou false caso n�o encontre nenhum fragmento para este bloco.

Definition at line 1371 of file RioNeti.cpp.

{
    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - thereAreFragments] Start" << endl;
    #endif

    RioNetiReqIdItem *current    = NULL;
    RioNetiReqIdItem *previous   = NULL;
    int               ix         = 0;
    NetBuf           *nbp        = NULL;
    RioRequest       *request    = NULL;

    for( ix = 0; ix < XM_REQNUM; ix++ )
    {
        for( nbp = reqarray[ix]; nbp != NULL; nbp = nbp->nb_link )
        {
            if( nbp->nb_unicastRequested )
            {
                request = (RioRequest*)(nbp->nb_userparm);
                if( request->Block ==  block )
                {
                    #ifdef RIO_DEBUG2
                    m_log << "[RioNeti - thereAreFragments] Encontrados "
                           << "fragmentos do bloco unicast " << block
                           << " de reqid " << nbp->nb_reqid << endl;
                    #endif

                    #ifdef RIO_DEBUG1
                    m_log << "[RioNeti - thereAreFragments] Finish 1" << endl;
                    #endif

                    return true;
                }
            }
            else
            {
                int result = reqid_table->Search( (int) block, &current,
                                                  &previous );

                if( result == RESULT_NETIREQT_SEARCH_FOUND )
                {
                    #ifdef RIO_DEBUG2
                    m_log << "[RioNeti - thereAreFragments] Encontrados "
                           << "fragmentos do bloco multicast " << block
                           << " de reqid " << nbp->nb_reqid << endl;
                    #endif

                    #ifdef RIO_DEBUG1
                    m_log << "[RioNeti - thereAreFragments] Finish 2" << endl;
                    #endif

                    return true;
                }
            }
        }
    }

    #ifdef RIO_DEBUG1
    m_log << "[RioNeti - thereAreFragments] Finish 3" << endl;
    #endif

    return false;
}

---

Field Documentation

BufferStream* RioNeti::buffer_stream [private]

Definition at line 219 of file RioNeti.h.

callback_t RioNeti::callback [private]

Definition at line 220 of file RioNeti.h.

RioCallBackTransport* RioNeti::callback_transport [private]

Definition at line 221 of file RioNeti.h.

int RioNeti::cnt_rcvfragack [private]

Definition at line 320 of file RioNeti.h.

int RioNeti::cnt_rcvfragacknc [private]

Definition at line 321 of file RioNeti.h.

int RioNeti::cnt_rcvpkt [private]

Definition at line 316 of file RioNeti.h.

int RioNeti::cnt_retry [private]

Definition at line 317 of file RioNeti.h.

int RioNeti::cnt_rst1 [private]

Definition at line 318 of file RioNeti.h.

int RioNeti::cnt_rst2 [private]

Definition at line 319 of file RioNeti.h.

int RioNeti::cnt_sndpkt [private]

Definition at line 315 of file RioNeti.h.

const int RioNeti::DEBUG_CMDS = (1 << 5) [static, private]

Definition at line 269 of file RioNeti.h.

const int RioNeti::DEBUG_CNT = (1 << 0) [static, private]

Definition at line 265 of file RioNeti.h.

const int RioNeti::DEBUG_DATA = (1 << 4) [static, private]

Definition at line 268 of file RioNeti.h.

const int RioNeti::DEBUG_FRAG = (1 << 2) [static, private]

Definition at line 266 of file RioNeti.h.

const int RioNeti::DEBUG_MISC = (1 << 6) [static, private]

Definition at line 270 of file RioNeti.h.

const int RioNeti::DEBUG_MORE = (1 << 8) [static, private]

Definition at line 271 of file RioNeti.h.

const int RioNeti::DEBUG_TIM = (1 << 3) [static, private]

Definition at line 267 of file RioNeti.h.

const int RioNeti::DEBUG_TIMEOUT = (1 << 10) [static, private]

Definition at line 272 of file RioNeti.h.

int RioNeti::err_dupfrag [private]

Definition at line 322 of file RioNeti.h.

int RioNeti::err_overfrag [private]

Definition at line 323 of file RioNeti.h.

int RioNeti::err_pktcmd [private]

Definition at line 327 of file RioNeti.h.

int RioNeti::err_pktfmt [private]

Definition at line 328 of file RioNeti.h.

int RioNeti::err_pktmagic [private]

Definition at line 325 of file RioNeti.h.

int RioNeti::err_pktnoreq [private]

Definition at line 326 of file RioNeti.h.

int RioNeti::err_pktsize [private]

Definition at line 324 of file RioNeti.h.

pthread_mutex_t RioNeti::HashMutex [private]

Definition at line 275 of file RioNeti.h.

bool RioNeti::m_behindnat [private]

Definition at line 294 of file RioNeti.h.

pthread_mutex_t RioNeti::m_buf_lock [private]

Definition at line 276 of file RioNeti.h.

void* RioNeti::m_cmdparm [private]

Definition at line 312 of file RioNeti.h.

cmdcallback_t RioNeti::m_cmdproc [private]

Definition at line 311 of file RioNeti.h.

NetBuf* RioNeti::m_cmpltf [private]

Definition at line 333 of file RioNeti.h.

NetBuf* RioNeti::m_cmpltl [private]

Definition at line 334 of file RioNeti.h.

int RioNeti::m_debug [private]

Definition at line 208 of file RioNeti.h.

pthread_mutex_t RioNeti::m_dns_lock [private]

Definition at line 277 of file RioNeti.h.

struct sockaddr_in RioNeti::m_fraddr [private]

Definition at line 313 of file RioNeti.h.

int RioNeti::m_fraddrl [private]

Definition at line 310 of file RioNeti.h.

int RioNeti::m_ipaddr [private]

Definition at line 289 of file RioNeti.h.

int* RioNeti::m_ipaddrmap [private]

Definition at line 291 of file RioNeti.h.

int RioNeti::m_ipport [private]

Definition at line 290 of file RioNeti.h.

int* RioNeti::m_ipportmap [private]

Definition at line 293 of file RioNeti.h.

debugCerr RioNeti::m_log [static, private]

Definition at line 352 of file RioNeti.h.

CLogRotation* RioNeti::m_LogRotation [private]

Definition at line 371 of file RioNeti.h.

struct NATMappingInfo* RioNeti::m_MappingInfo [private]

Definition at line 299 of file RioNeti.h.

unsigned int RioNeti::m_MappingInfoSize [private]

Definition at line 303 of file RioNeti.h.

int RioNeti::m_maxdiskl [private]

Definition at line 307 of file RioNeti.h.

int RioNeti::m_maxpktl [private]

Definition at line 306 of file RioNeti.h.

NetBuf* RioNeti::m_outqf [private]

Definition at line 335 of file RioNeti.h.

NetBuf* RioNeti::m_outql [private]

Definition at line 336 of file RioNeti.h.

int RioNeti::m_sock [private]

Definition at line 273 of file RioNeti.h.

CStreamControl* RioNeti::m_StreamControl [private]

Definition at line 367 of file RioNeti.h.

pthread_mutex_t RioNeti::m_TcpLock [private]

Definition at line 280 of file RioNeti.h.

pthread_t RioNeti::m_TcpServerThread [private]

Definition at line 281 of file RioNeti.h.

pthread_t RioNeti::m_thread [private]

Definition at line 274 of file RioNeti.h.

pthread_t RioNeti::m_threadmap [private]

Definition at line 296 of file RioNeti.h.

int RioNeti::m_threadstop [private]

Definition at line 308 of file RioNeti.h.

struct sockaddr_in RioNeti::m_toaddr [private]

Definition at line 314 of file RioNeti.h.

int RioNeti::m_toaddrl [private]

Definition at line 309 of file RioNeti.h.

int RioNeti::max_in_set [private]

Definition at line 226 of file RioNeti.h.

NetBuf* RioNeti::mbc_free [private]

Definition at line 342 of file RioNeti.h.

int RioNeti::mbc_num [private]

Definition at line 343 of file RioNeti.h.

pthread_t RioNeti::mThread [private]

Definition at line 207 of file RioNeti.h.

struct MulticastInfo RioNeti::multicastInfo[MULTICAST_SOCKETS] [private]

Definition at line 228 of file RioNeti.h.

struct sockaddr_in RioNeti::myAddress [private]

Definition at line 234 of file RioNeti.h.

struct timeval RioNeti::next [private]

Definition at line 338 of file RioNeti.h.

unsigned int RioNeti::numPkts [private]

Definition at line 206 of file RioNeti.h.

fd_set RioNeti::readfds [private]

Definition at line 340 of file RioNeti.h.

NetBuf* RioNeti::reqarray[XM_REQNUM] [private]

Definition at line 345 of file RioNeti.h.

RioNetiReqIdTable* RioNeti::reqid_table [private]

Definition at line 209 of file RioNeti.h.

int RioNeti::reqseq [private]

Definition at line 344 of file RioNeti.h.

bool RioNeti::serverInstance [private]

Definition at line 223 of file RioNeti.h.

pthread_mutex_t RioNeti::socketMulticastMutex [private]

Definition at line 229 of file RioNeti.h.

const int RioNeti::TimeShift = 10 [static, private]

Definition at line 283 of file RioNeti.h.

fd_set RioNeti::writefds [private]

Definition at line 341 of file RioNeti.h.

fd_set* RioNeti::writefdsp [private]

Definition at line 339 of file RioNeti.h.

struct timeval RioNeti::xm_now [private]

Definition at line 337 of file RioNeti.h.

const int RioNeti::XM_REQBITS = 8 [static, private]

Definition at line 284 of file RioNeti.h.

const int RioNeti::XM_REQMASK = (XM_REQNUM-1) [static, private]

Definition at line 286 of file RioNeti.h.

const int RioNeti::XM_REQNUM = (1 << XM_REQBITS) [static, private]

Definition at line 285 of file RioNeti.h.

int RioNeti::xm_rstip [private]

Definition at line 330 of file RioNeti.h.

int RioNeti::xm_rstport [private]

Definition at line 331 of file RioNeti.h.

int RioNeti::xm_rstreqid [private]

Definition at line 332 of file RioNeti.h.

int RioNeti::xm_rstsec [private]

Definition at line 329 of file RioNeti.h.

---

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

• RioNeti.h
• RioNeti.cpp