Phenquestions
Comunicação entre processos POSIX (IPC)
IPC é usado para extensões em tempo real. Essas filas de mensagens fazem parte do Linux. Essas chamadas são usadas como padrão agora, mas podem fazer parte de versões contemporâneas. Essas chamadas são fáceis de implementar com uma interface muito mais limpa.
POSIX Message Queues no Linux
V filas de mensagens em um sistema Linux são identificadas usando chaves que são obtidas usando Ftok chamadas. Essas filas de mensagens POSIX geralmente usam strings de nome. Em sistemas Linux, as filas POSIX são chamadas de strings. Essas strings são consideradas como começando com / e, em seguida, têm outros caracteres. Os processos que seguem e sabem o nome do nome da fila com os direitos apropriados podem enviar ou receber mensagens de e para a fila. Isso ajudará na execução de funcionalidades importantes.
O que são chamadas de fila de mensagens POSIX?
As filas de mensagens POSIX devem ser vinculadas a qualquer biblioteca que saia de verdade. A seguir estão algumas chamadas que são usadas:
librt usa a opção do compilador -lrtOs nomes das chamadas começam com mq_prefix
Os detalhes das chamadas em fila são discutidos abaixo:
>> mq_open, mq_close
Esta função é usada para abrir uma fila POSIX.
Mq_open é uma função que é usada para chamar o nome da fila. O próximo parâmetro é um sinalizador usado para receber as mensagens. O_WRONLY é usado para enviar mensagens e O_RDWR é usado para enviar e receber operações dentro da fila. Os usuários podem usar o sinalizador O_NONBLOCK para especificar a fila para o modo sem bloqueio e mq_send e mq_receive para enviar e receber dados em uma fila.
Sintaxe
A sintaxe para a chamada em fila acima é exibida abaixo:
/ * usado para abrir os arquivos * /
#incluir
/ * para determinar um arquivo com base no caminho * /
#incluir
/ * para incluir descrições da fila de mensagens * /
mqd_t mq_open (caractere const * nome, int oflag);
/ * para abrir e acessar a fila * /
mqd_t mq_open (caractere const * nome, int oflag, modo mode_t,
struct mq_attribute * attribute);
Mq_Flags: Pode ser O ou não bloqueado
Mq_MaxMsg: Número máximo de mensagens que podem ser inseridas na fila
Mq_Msgsize: Número máximo de bytes em uma mensagem
Mq_CurMsgs: Mensagens enviadas atualmente em uma fila
chamadas mq_close: Para fechar todos os descritores de fila.
mq_notify
É uma chamada usada para registrar e cancelar o registro de notificação de chegada quando uma mensagem entra em uma fila vazia.
Sintaxe
#incluir/ * para incluir todas as descrições da fila de mensagens do código * /
int mq_notify (mqd_t mqdes, const struct sigevent * sevp);
/ * para notificar a chegada da mensagem em uma fila * /
mq_unlink
É usado para remover a fila com queue_name.
Sintaxe
int mq_unlink (const char * queue_name);/ * Para remover a fila cujo nome é queue_name * /
mq_getattr, mq_setattr
Esta função possui uma estrutura de atributos:
struct mq_attr é usado como uma fila de mensagens para descritores.
mq_setattr é usado para definir os atributos dentro de uma fila.
Sintaxe
#incluirint mq_getattribute (mqd_t mqdes, atributo struct mq_attribute *);
int mq_setattribute (mqd_t mqdes, const struct mq_attribute * newattribute,
struct mq_attribute * oldattr);
Exemplo: comunicação cliente-servidor via POSIX
A seguir está um exemplo de realização de comunicação cliente-servidor via filas de mensagens POSIX. No exemplo, teremos um arquivo do cliente e um arquivo do servidor.
Teremos dois arquivos: o primeiro arquivo (servidor) é servidor.c, e o outro arquivo (cliente) é cliente.c.
Código do Servidor
A imagem exibida abaixo mostra o código que usamos para a comunicação cliente-servidor. Primeiro, chamamos algumas bibliotecas para definir as strings, variáveis e funções. Então, definimos o fcntl função e o nome do servidor de fila. Depois disso, definimos o nome da fila do servidor, seguido por seu tamanho de mensagem e tamanho do buffer, para definir o tamanho das mensagens para caber em nosso buffer de cada vez. Em seguida, chamamos e descrevemos as filas, em seguida, geramos os próximos tokens para ver a resposta do cliente, uma vez que foi enviada para o cliente. Por fim, a confirmação foi concluída imprimindo a mensagem do lado do servidor. Na próxima seção, você verá os sinalizadores discutidos na seção anterior.
Inicializamos todos os sinalizadores, incluindo mq_flags, mq_maxmsgs, etc. para prosseguir com o armazenamento de solicitações. Em seguida, aplicamos a condição ao nome do servidor e armazenamos as mensagens no buffer da fila. Depois disso, no momento do armazenamento, garantimos que as filas seguissem uma regra de prioridade baseada na ordem de chegada. No final, o código exibe uma mensagem de falha se houver algum erro recebido do cliente. Por fim, saímos do servidor para enviar a solicitação ao cliente.
Salve o servidor.arquivo c
Código do cliente
Vamos agora discutir o segundo arquivo. A imagem exibida abaixo é o código que usamos para a comunicação cliente-servidor. O código começou chamando bibliotecas padrão e definindo cabeçalhos de variáveis. Então, definimos as strings e todos os tipos de dados. Depois disso, declaramos o cabeçalho da fila para definir o nome da fila do servidor. Em seguida, definimos as filas de permissão e o tamanho da mensagem dentro da fila, junto com o tamanho do buffer de mensagem (o tamanho máximo que caberia dentro da fila).
Vamos descrever as filas e criar um novo cliente para receber as mensagens enviadas do final do servidor. Então, vamos chamar os sinalizadores e inicializá-los, e chamar a função de cliente final. Ele sairá da função em caso de erro. O valor é armazenado dentro do buffer e uma resposta do pedido é enviada ao servidor. No caso de uma resposta, o servidor irá fornecer o token, que é impresso assim que o cliente entrar na entrada. Em caso de erro, ele retornará os valores de erro, i.e., o cliente não conseguiu enviar uma mensagem ao servidor. Depois disso, vamos sair do cliente.
Salve o cliente.arquivo c
Executando os Arquivos
Estamos usando um gcc compilador para executar os arquivos. Para executar o arquivo final do servidor, digite o comando anexado na janela do terminal:
servidor $ sudo gcc.c-lrt
Em seguida, digite o seguinte:
$ ./uma.Fora
A saída aparecerá da seguinte maneira:
Passando para a resposta do cliente, digite o seguinte:
cliente $ sudo gcc.c-lrt
Em seguida, execute o seguinte:
$ ./uma.Fora
A saída aparecerá da seguinte maneira:
Conclusão
Neste artigo, você aprendeu como enviar Filas de Mensagens POSIX com programação C, bem como algumas de suas funções. Então, você viu alguns exemplos desse processo em maiores detalhes.
