Phenquestions
POSIX interprosesskommunikasjon (IPC)
IPC brukes til sanntidsutvidelser. Disse meldingskøene er en del av Linux. Disse samtalene brukes som standard nå, men kan være en del av moderne versjoner. Disse samtalene er enkle å implementere med et mye renere grensesnitt.
POSIX meldingskøer i Linux
V-meldingskøer i et Linux-system identifiseres ved hjelp av nøkler som fås ved hjelp av ftok ringer. Disse POSIX-meldingskøene bruker vanligvis navnestrenger. I Linux-systemer kalles POSIX-køer strenger. Disse strengene anses å starte med / og har deretter andre tegn. Prosesser som følger og kjenner navnet på kønavnet med passende rettigheter, kan sende eller motta meldinger til og fra køen. Dette vil hjelpe deg med å utføre viktige funksjoner.
Hva er POSIX-meldingskøanrop?
POSIX-meldingskøer må koble til ethvert bibliotek som går ut på ekte. Følgende er noen få samtaler som brukes:
librt bruker kompilatoralternativet -lrtKallnavn begynner med mq_prefix
Detaljene for køanrop blir diskutert nedenfor:
>> mq_open, mq_close
Denne funksjonen brukes til å åpne en POSIX-kø.
Mq_open er en funksjon som brukes til å ringe navnet på køen. Den neste parameteren er et flagg som brukes til å motta meldingene. O_WRONLY brukes til å sende meldinger, og O_RDWR brukes til å sende og motta operasjoner i køen. Brukere kan bruke O_NONBLOCK-flagget til å spesifisere køen til ikke-blokkerende modus og mq_send og mq_ motta for å sende og motta data i kø.
Syntaks
Syntaksen for ovennevnte køanrop vises nedenfor:
/ * brukes til å åpne filene * /
#inkludere
/ * for å bestemme en fil basert på banen * /
#inkludere
/ * for å inkludere meldingskøbeskrivelser * /
mqd_t mq_open (const tegn * navn, int oflag);
/ * for å åpne og få tilgang til køen * /
mqd_t mq_open (const character * name, int oflag, mode_t mode,
struct mq_attribute * attributt);
Mq_Flags: Kan være O eller ikke-blokk
Mq_MaxMsg: Maksimalt antall meldinger som kan legges inn i køen
Mq_Msgsize: Maksimalt antall byte i en melding
Mq_CurMsgs: For tiden sendte meldinger i en kø
mq_close samtaler: For å lukke alle købeskrivelsene.
mq_notify
Det er en samtale som brukes til å registrere og avregistrere ankomstvarsling når en melding går inn i en tom kø.
Syntaks
#inkludere/ * for å inkludere alle meldingskøbeskrivelsene fra koden * /
int mq_notify (mqd_t mqdes, const struct sigevent * sevp);
/ * for å varsle ankomsten av meldingen i en kø * /
mq_unlink
Den brukes til å fjerne køen som har kønavn.
Syntaks
int mq_unlink (const char * kønavn);/ * For å fjerne køen med navn som kønavn * /
mq_getattr, mq_setattr
Denne funksjonen har en attributtstruktur:
struct mq_attr brukes som en meldingskø for beskrivere.
mq_setattr brukes til å sette attributtene i en kø.
Syntaks
#inkludereint mq_getattribute (mqd_t mqdes, struct mq_attribute * attributt);
int mq_setattribute (mqd_t mqdes, const struct mq_attribute * newattribute,
struct mq_attribute * oldattr);
Eksempel: Klient-server kommunikasjon via POSIX
Følgende er et eksempel på å utføre klient-server-kommunikasjon via POSIX-meldingskøer. I eksemplet vil vi ha en klientfil og serverfil.
Vi vil ha to filer: den første (server) filen er server.c, og den andre (klient) filen er klient.c.
Serverkode
Bildet som vises nedenfor viser koden vi brukte for klient-server-kommunikasjon. Først kalte vi noen biblioteker for å definere strengene, variablene og funksjonene. Så definerte vi fcntl funksjon og navnet på køserveren. Etter det definerte vi navnet på serverkøen, etterfulgt av meldingsstørrelse og bufferstørrelse, for å definere størrelsen på meldinger som passer til bufferen vår om gangen. Deretter ringte og beskrev vi køene, så genererte vi de neste tokens for å se klientsvaret når det ble sendt til klienten. Til slutt ble bekreftelsen fullført ved å skrive ut meldingen fra serverenden. I neste avsnitt vil du se flaggene som ble diskutert i den tidligere delen.
Vi initialiserte alle flagg, inkludert mq_flags, mq_maxmsgs, etc. for å fortsette med lagring av forespørsler. Deretter brukte vi tilstanden på navnet på serveren og lagret meldingene i købufferen. Etter dette, på tidspunktet for lagring, sørget vi for at køene fulgte en først til mølle-basert prioritetsregel. På slutten viser koden en feilmelding hvis det er feil mottatt fra klientens slutt. Til slutt forlot vi serveren for å sende forespørselen til klienten.
Lagre serveren.c-fil
Kundekode
Vi vil nå diskutere den andre filen. Bildet som vises nedenfor er koden vi brukte for klient-server-kommunikasjonen. Koden begynte med å ringe til standardbiblioteker og definere variable overskrifter. Deretter definerte vi strengene og alle typer data. Etter det erklærte vi overskriften til køen for å definere serverkønavnet. Deretter definerte vi tillatelseskøene og meldingsstørrelsen inne i køen, sammen med størrelsen på meldingsbufferen (maksimal størrelse som kunne passe inne i køen).
Vi vil beskrive køene og opprette en ny klient for å motta meldingene som sendes fra slutten av serveren. Deretter vil vi ringe flaggene og initialisere dem, og ringe klient-sluttfunksjonen. Den avslutter funksjonen i tilfelle en feil. Verdien lagres inne i bufferen, og et forespørselssvar sendes til serveren. I tilfelle svar, vil serveren da levere tokenet, som skrives ut når klientenden har skrevet inn inngangen. I tilfelle en feil vil den returnere feilverdiene, dvs.e., klienten har ikke klart å sende en melding til serveren. Etter det avslutter vi klienten.
Lagre klienten.c-fil
Utføre filene
Vi bruker en gcc kompilator for å utføre filene. For å kjøre serverens sluttfil, skriv inn den vedlagte kommandoen i terminalvinduet:
$ sudo gcc-server.c -lrt
Skriv deretter inn følgende:
$ ./en.ute
Utgangen vises som følger:
Gå videre til klientsvaret og skriv inn følgende:
$ sudo gcc-klient.c -lrt
Kjør deretter følgende:
$ ./en.ute
Utgangen vises som følger:
Konklusjon
I denne artikkelen lærte du hvordan du sender POSIX-meldingskøer med C-programmering, samt noen av funksjonene. Så så du noen eksempler på denne prosessen mer detaljert.
