Mesaj Kuyrukları

Mesaj kuyrukları kullanımı kolay, client-server haberleşmeye olanak sağlayan IPC
mekanizmasıdır. Mesaj kuyruğu mekanizması Windows programlamadaki PostMessage-
GetMessage çalışma biçimine çok benzer. Yani gönderen taraf kuyruğa mesajı bırakır. Alıcı
taraf kuyrukta mesaj olmadığı sürece bloke olarak bekler, sonra işlemler böyle devam eder.
Mesaj kuyruğu msgget fonksiyonuyla yaratılır.

int msgget(key_t key, int flag);
flag IPC_CREAT ve IPC_EXCL bileşimlerinden oluşabilir ya da 0 geçilebilir. flag ayrıca
erişim bilgileriyle kombine edilebilir.
msgsnd Fonksiyonu
Bu fonksiyon mesaj kuyruğuna mesaj göndermek için kullanılır.

int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag);
Fonksiyonun birinci parametresi mesaj kuyruğunun ID değeri, ikinci parametresi
gönderilecek mesajın adresidir. Üçüncü parametre ikinci parametrede belirtilen adresten
itibaren kaç byte’lık bir mesaj gönderileceğini belirtir. Son parametre IPC_NOWAIT ya da 0
biçiminde olabilir.

Normalde mesaj kuyruğu sınıra dayandığı için dolu olabilir ve bu durumda yer açılana kadar
msgsnd bloke olur. Eğer flag 0 yerine IPC_NOWAIT olarak girilirse fonksiyon bloke olmaz,
başarısızlıkla geri döner. İkinci parametrede belirtilen mesajın yapısı önce bir long ID değeri
içerecek biçimde olmalıdır. Yani gönderilecek mesajın ilk sizeof(long) kadar kısmı mesajda
kesinlikle olmak zorundadır, yapının diğer elemanları programcı tarafından serbest olarak
oluşturulabilir. Fonksiyonun üçüncü parametresinde belirtilen uzunluk bu ilk long elemanını
kapsamamaktadır. Fonksiyon başarılıysa 0, başarısızsa –1 değerine geri döner. Programcı
mesajlarına çeşitli numaralar atayabilir. Yapının ilk long elemanı bu amaçla kullanılmaktadır.
Böylece alıcı taraf istediği mesajları filtreleyebilir ya da mesajın türüne göre işlemlerini
düzenleyebilir.

msgrcv Fonksiyonu
Bu fonksiyon mesaj kuyruğundan istenilen ID’ye sahip olan mesajı almakta kullanılır.
int msgrcv(int msqid, void *ptr, size_t nbytes, long type, int flag);
Fonksiyonun birinci parametresi mesaj kuyruğunun ID değeri, ikinci parametresi mesajın
yerleştirileceği adrestir. Üçüncü parametre mesajdan okunacak byte sayısıdır. type
parametresi üç seçenekten biri olabilir:

1) type == 0, bu durumda kuyruktaki ilk mesaj alınır.
2) type > 0, bu durumda ID’si type olan ilk mesaj alınır.
3) type < 0, bu durumda kuyruktaki abs(type) >= ID olan en küçük mesaj alınır.

Kuyruktaki mesajlardan abs(type) değerinden küçük ya da eşit olan en küçük ID’li mesaj
alınır. type == -6 ise 3 ID’li mesaj alınacaktır.
Örneğin kuyrukta 3, 5, 8 ID’lerine sahip 3 mesaj bulunsun (3 ilk mesaj, 8 son gönderilen
mesajdır). type == 0 ise ilk mesaj olan 3 numaralı mesaj alınır. type == 8 ise 8 diğer mesajlar
atlanarak ID’si 8 olan mesaj alınır.
Sınıf çalışması: Mesaj kuyruğu yaratan aşağıdaki programı yazınız.
Açıklamalar:

1) Programın ismi msgcreate olacaktır ve bir komut satırı argümanı alacaktır. Bu argüman
bir dosya ismi olacaktır.
2) Komut argv[1]’den alınan dosya ismi ftok fonksiyonuna sokulacak ve bir anahtar değer
elde edilecektir. ftok fonksiyonunun ikinci parametresi 1 alınacaktır.
3) ftok fonksiyonundan alınan anahtar değer ile msgget fonksiyonu çağırılacak msgget
fonksiyonunda flag olarak IPC_CREAT | 0666 verilecektir.

/* msgcreate.c */
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
key_t key;
int msgReturn;
if (argc != 2) {
fprintf(stderr, "argc failed!..\n");
exit(1);
}
key = ftok(argv[1], 1);
if (key == -1) {
perror("ftok");
exit(1);
}
msgReturn = msgget(key, IPC_CREAT | 0666);
if (msgReturn == -1) {
perror("msgget");
exit(1);
}
return 0;
}

Sınıf Çalışması: Belirtilen bir kuyruğa mesaj gönderen ve mesaj alan programları ayrı ayrı
yazınız.
Açıklamalar:
1) Mesaj gönderen program msgsnd isminde olacak ve üç komut satırı argümanı alacaktır.
msgsnd <dosya_ismi> <mesaj id’si> <”mesaj metni”>
Program birinci parametresiyle belirtilen dosya ismini kullanarak ftok fonksiyonu ile bir
anahtar elde edecek, iki ve üçüncü parametrelerle belirtilen mesajı kuyruğa msgsnd
fonksiyonu ile yollayacaktır.
2) msgget fonksiyonunda flag değeri 0 geçilebilir.
3) Mesaj almak için kullanılan programın ismi msgrcv olacaktır. Bu program iki komut satırı
argümanı alacaktır.
msgrcv <dosya_ismi> <mesaj id’si>
Program yine msgget ile mesaj kuyruğunu yaratacak ve belirtilen ID’ye sahip mesajı
alacaktır. Bu ID doğrudan msgrcv fonksiyonunda kullanılacağından dolayı pozitif, 0 ya da
negatif olabilir. msgrcv fonksiyonunda mesaj uzunluğunda büyük bir uzunluk girilebilir.
msgrcv bu mesajı alarak ekrana yazdıracaktır.

/* msgrcv.c */
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <string.h>
typedef struct tagMSG{
long id;
char buf[100];
} MSG;
int main(int argc, char *argv[])
{
key_t key;
int msgReturn;
int msgReceive;
MSG msg;
if (argc != 3) {
fprintf(stderr, "argc failed!..\n");
exit(1);
}
key = ftok(argv[1], 1);
if (key == -1) {
perror("ftok");
exit(1);
}
msgReturn = msgget(key, 0);
if (msgReturn == -1) {
perror("msgget");
exit(1);
}
msg.id = atoi(argv[2]);
msgReceive = msgrcv(msgReturn, &msg, sizeof(MSG), msg.id, 0);
if (msgReceive == -1) {
perror("msgsnd");
exit(1);
}
printf("id = %d msg = %s\n", msg.id, msg.buf);
return 0;
}
/* msgsnd.c */
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <string.h>
typedef struct tagMSG{
long id;
char buf[100];
} MSG;
int main(int argc, char *argv[])
{
key_t key;
int msgReturn;
int msgSend;
MSG msg;
if (argc != 4) {
fprintf(stderr, "argc failed!..\n");
exit(1);
}
key = ftok(argv[1], 1);
if (key == -1) {
perror("ftok");
exit(1);
}
msgReturn = msgget(key, 0);
if (msgReturn == -1) {
perror("msgget");
exit(1);
}
msg.id = atoi(argv[2]);
strcpy(msg.buf, argv[3]);
msgSend = msgsnd(msgReturn, &msg, sizeof(MSG), 0);
if (msgSend == -1) {
perror("msgsnd");
exit(1);
}
return 0;

}

 

Yorum Yapabilmek İçin Üye Girişi Yapmanız Gerekmektedir.

mesaj kuyrukları