Phenquestions
Comunicazione tra processi POSIX (IPC)
IPC viene utilizzato per estensioni in tempo reale. Queste code di messaggi fanno parte di Linux. Queste chiamate sono ora utilizzate come standard ma potrebbero far parte delle versioni contemporanee. Queste chiamate sono facili da implementare con un'interfaccia molto più pulita.
Code di messaggi POSIX in Linux
Le code di messaggi V in un sistema Linux vengono identificate utilizzando le chiavi ottenute utilizzando ftok chiama. Queste code di messaggi POSIX di solito usano stringhe di nomi. Nei sistemi Linux, le code POSIX sono chiamate stringhe. Si considera che queste stringhe inizino con / e poi abbiano altri caratteri. I processi che seguono e conoscono il nome della coda con i diritti appropriati possono inviare o ricevere messaggi da e verso la coda. Questo aiuterà a svolgere importanti funzionalità.
Cosa sono le chiamate POSIX Message Queue??
Le code di messaggi POSIX devono essere collegate a qualsiasi libreria che esce per davvero. Di seguito sono riportate alcune chiamate utilizzate:
librt usa l'opzione del compilatore -lrtI nomi delle chiamate iniziano con mq_prefix
I dettagli delle chiamate in coda sono discussi di seguito:
>> mq_apri, mq_chiudi
Questa funzione viene utilizzata per aprire una coda POSIX.
Mq_open è una funzione che viene utilizzata per chiamare il nome della coda. Il parametro successivo è un flag utilizzato per ricevere i messaggi. O_WRONLY viene utilizzato per inviare messaggi e O_RDWR viene utilizzato per inviare e ricevere operazioni all'interno della coda. Gli utenti possono utilizzare il flag O_NONBLOCK per specificare la coda in modalità non bloccante e mq_invia e mq_ricevere inviare e ricevere dati in coda.
Sintassi
La sintassi per la chiamata in coda di cui sopra è visualizzata di seguito:
/* usato per aprire i file */
#includere
/* per determinare un file in base al percorso */
#includere
/* per includere le descrizioni della coda dei messaggi */
mqd_t mq_open (const carattere *nome, int oflag);
/* per aprire e accedere alla coda */
mqd_t mq_open (const carattere *nome, int oflag, mode_t mode,
struct mq_attributo *attributo);
Mq_Flags: Potrebbe essere O o non-block
Mq_MaxMsg: Numero massimo di messaggi che possono essere inseriti nella coda
Mq_Msgsize: Numero massimo di byte in un messaggio
Mq_CurMsgs: Messaggi attualmente inviati all'interno di una coda
mq_chiudi chiamate: Per chiudere tutti i descrittori di coda.
mq_notifica
È una chiamata utilizzata per registrare e annullare la registrazione della notifica di arrivo quando un messaggio entra in una coda vuota.
Sintassi
#includere/* per includere tutte le descrizioni della coda dei messaggi dal codice */
int mq_notify (mqd_t mqdes, const struct sigevent *sevp);
/* per notificare l'arrivo del messaggio in coda */
mq_unlink
Viene utilizzato per rimuovere la coda con nome_coda.
Sintassi
int mq_unlink(const char *queue_name);/* Per rimuovere la coda il cui nome è queue_name */
mq_getattr, mq_setattr
Questa funzione ha una struttura di attributi:
struct mq_attr viene utilizzato come coda di messaggi per i descrittori.
mq_setattr viene utilizzato per impostare gli attributi all'interno di una coda.
Sintassi
#includereint mq_getattribute(mqd_t mqdes, struct mq_attribute *attribute);
int mq_setattribute(mqd_t mqdes, const struct mq_attribute *newattribute,
struct mq_attribute*oldattr);
Esempio: comunicazione client-server tramite POSIX
Di seguito è riportato un esempio di esecuzione della comunicazione client-server tramite code di messaggi POSIX. Nell'esempio, avremo un file client e un file server.
Avremo due file: il primo file (server) è server.c, e l'altro file (client) è cliente.c.
Codice server
L'immagine mostrata sotto mostra il codice che abbiamo usato per la comunicazione client-server. Per prima cosa, abbiamo chiamato alcune librerie per definire le stringhe, le variabili e le funzioni. Quindi, abbiamo definito il fcntl funzione e il nome del server di coda. Successivamente, abbiamo definito il nome della coda del server, seguito dalla dimensione del messaggio e dalla dimensione del buffer, per definire la dimensione dei messaggi per adattarsi al nostro buffer alla volta. Successivamente, abbiamo chiamato e descritto le code, quindi abbiamo generato i token successivi per vedere la risposta del client una volta inviata al client. Infine, la conferma è stata completata stampando il messaggio dal server end. Nella sezione successiva, vedrai i flag discussi nella sezione precedente.
Abbiamo inizializzato tutti i flag, incluso mq_flags, mq_maxmsgs, eccetera. procedere con l'archiviazione delle richieste. Quindi, abbiamo applicato la condizione al nome del server e archiviato i messaggi nel buffer della coda. Successivamente, al momento dello stoccaggio, ci siamo assicurati che le code seguissero una regola di priorità in base all'ordine di arrivo. Alla fine, il codice visualizza un messaggio di errore se ci sono errori ricevuti dal client-end. Infine, siamo usciti dal server per inviare la richiesta al client.
Salva il server.c file
Codice Cliente
Discuteremo ora il secondo file. L'immagine mostrata sotto è il codice che abbiamo usato per la comunicazione client-server. Il codice è iniziato chiamando le librerie standard e definendo le intestazioni delle variabili. Quindi, abbiamo definito le stringhe e tutti i tipi di dati. Successivamente, abbiamo dichiarato l'intestazione della coda per definire il nome della coda del server. Successivamente, abbiamo definito le code di autorizzazione e la dimensione del messaggio all'interno della coda, insieme alla dimensione del buffer del messaggio (la dimensione massima che potrebbe adattarsi alla coda).
Descriveremo le code e creeremo un nuovo client per ricevere i messaggi inviati dalla fine del server. Quindi, chiameremo i flag, li inizializzeremo e chiameremo la funzione client-end. Uscirà dalla funzione in caso di errore. Il valore viene memorizzato all'interno del buffer e viene inviata una risposta di richiesta al server. In caso di risposta, il server fornirà quindi il token, che viene stampato una volta che il client ha inserito l'input. In caso di errore, restituirà i valori di errore, i.e., il client non è stato in grado di inviare un messaggio al server. Dopodiché, usciremo dal client.
Salva il cliente.c file
Esecuzione dei file
Stiamo usando a gcc compilatore per eseguire i file. Per eseguire il file finale del server, digita il comando allegato nella finestra del terminale:
$ sudo gcc server.c -lrt
Quindi, digita quanto segue:
$ ./un.su
L'output apparirà come segue:
Passando alla risposta del client, digita quanto segue:
$ sudo gcc client.c -lrt
Quindi eseguire quanto segue:
$ ./un.su
L'output apparirà come segue:
Conclusione
In questo articolo, hai imparato come inviare code di messaggi POSIX con la programmazione C, nonché alcune delle sue funzioni. Quindi, hai visto alcuni esempi di questo processo in modo più dettagliato.
