---

mensageiro.C

Ir para a documentação deste ficheiro.

#include <IPC/mensageiro.H>

bool IPC::Mensageiro::existe_instancia = false;

IPC::Mensageiro::Mensageiro(key_t const chave)
{
    assert(!existe_instancia);

    existe_instancia = true;

    /* Usa-se por omissão o getuid() para que a comunicação entre
       utilizadores não seja possível, eliminando-se assim muitos
       problemas. */
    int permissoes = (chave == key_t(getuid()))? 0660 : 0666;
    
    // Obtenção de PID do processo corrente e do UID do utilizador.
    eu = int(getpid());
    meuUID = int(getuid());
    
    // Criação de caixa do correio/obtenção de identificador de caixa
    // do correio existente:
    if((id = msgget(chave, IPC_CREAT | permissoes)) == -1)
        throw Erro();

    try {
        
        /* Tenta ler PID de um servidor do canal 1, que é o canal onde
           os servidores se registam.  Se a leitura falhar, não existe
           servidor registado, pelo que o corrente processo se
           assumirá como servidor. Note-se que esta utilização de
           excepções como substitutos de instruções de selecção não é
           boa ideia em geral. */
        outro = leBasicoInt(1, false);
        
        /* Encontrou registo de vervidor.  Nesse caso é
           cliente. */
        servidor = false;
        
        // Depois escreve o seu PID no canal do servidor */
        envia(eu);
        
    } catch(Erro) {
        
        /* Não encontrou registo de servidor.  Nesse caso é
           servidor e espera por um cliente. */
        servidor = true;
        
        /* O servidor regista a existência de actividade
           escrevendo uma mensagem irrelevante no canal 2, que
           é usado pelos serviddres para saberem se a caixa do
           correio deve ser eliminada quando eles terminam a
           execução. */
        escreveBasicoInt(2, 0);
        
        /* O servidor escreve o seu PID no canal 1. */
        escreveBasicoInt(1, eu);
        
        /* Depois fica à espera do PID do cliente mas já no
           seu próprio canal. */
        outro = intRecebido();
    }

    // Envia o UID ao "outro".
    envia(meuUID);

    // Recebe o UID do "outro".
    outroUID = intRecebido();
}

IPC::Mensageiro::~Mensageiro() 
{
    try {
        if(servidor) {

            /* Se é servidor espera por fim do cliente antes de
               terminar em paz. */
            string mensagem;
            while((mensagem = stringRecebida()) != "TeRmInEi")
                ;
                
            /* Servidor elimina um marcador de existência de
               actividade. */
            leBasicoInt(2);

            /* Se não há nenhum marcador de existência de actividade,
               remove a caixa do correio. Ver mais acima nota acerca
               de blocos de tentativa para substituir instruções de
               selecção. */
            try {
                leBasicoInt(2, false);
                escreveBasicoInt(2, 0);
            } catch(Erro) {
                msgctl(id, IPC_RMID, 0);
            }

        } else {
            // Clientes avisam servidores que vão terminar.
            envia("TeRmInEi");
        }
    } catch(Erro) {
        /* Se houve erro, ignorar...  Excepções em destrutores são
           má ideia.  Deixar uma caixa do correio criada não
           incomoda muito... */
    }
}

string IPC::Mensageiro::leBasico(int const tipo, bool const espera) 
{
    typedef string::size_type Tamanho;
    int flag = espera? 0 : IPC_NOWAIT;

    // Receber tamanho da mensagem:
    msgbuf *mensagem_ipc = 
        static_cast<msgbuf*>(malloc(sizeof(long) + sizeof(Tamanho)));
    if(msgrcv(id, mensagem_ipc, sizeof(Tamanho), tipo, flag) == -1)
        throw Erro();
    Tamanho tamanho;
    memcpy(static_cast<void*>(&tamanho), 
           static_cast<void*>(mensagem_ipc->mtext),
           sizeof(Tamanho));
    free(mensagem_ipc);

    // Enviar memsagem:
    mensagem_ipc = 
        static_cast<msgbuf*>(malloc(sizeof(long) + tamanho + 1));
    if(msgrcv(id, mensagem_ipc, tamanho + 1, tipo, flag) == -1)
        throw Erro();
    string mensagem = mensagem_ipc->mtext;
    free(mensagem_ipc);

    return mensagem;
}

void IPC::Mensageiro::escreveBasico(int const tipo, string const& mensagem) 
{
    typedef string::size_type Tamanho;

    // Enviar tamanho da mensagem:
    msgbuf *mensagem_ipc = 
        static_cast<msgbuf*>(malloc(sizeof(long) + sizeof(Tamanho)));
    mensagem_ipc->mtype = tipo;
    Tamanho tamanho = mensagem.size();
    memcpy(static_cast<void*>(mensagem_ipc->mtext),
           static_cast<void*>(&tamanho), sizeof(Tamanho));
    if(msgsnd(id, mensagem_ipc, sizeof(Tamanho), IPC_NOWAIT) == -1)
        throw Erro();
    free(mensagem_ipc);

    // Enviar memsagem:
    mensagem_ipc = 
        static_cast<msgbuf*>(malloc(sizeof(long) + tamanho + 1));
    mensagem_ipc->mtype = tipo;
    strcpy(mensagem_ipc->mtext, mensagem.c_str());
    if(msgsnd(id, mensagem_ipc, tamanho + 1, IPC_NOWAIT) == -1)
        throw Erro();
    free(mensagem_ipc);
}

---