Controllo degli accessi alle risorse - La struttura "ipc_perm"

Code di messaggi

Si tratta di code contenenti dei messaggi. Ogni messaggio si compone di un campo message type (un numero) e di un campo message data. Una coda di messaggi può essere privata o pubblica: se pr 949j94j ivata può essere acceduta solamente dal processo che l'ha creata o da uno dei suoi processi figli; se pubblica può essere acceduta da tutti quei processi che conoscono la chiave della coda. Un processo generalmente scrive o legge messaggi all'interno della coda dopo esservi acceduto. L'ordine di lettura dei messaggi non prevede che vi sua una coda FIFO. Il fatto d spedire messaggi separati implica che tra la fine di un messaggio e l'inizio del successivo ci sia un byte che funga da separatore tra i pacchetti.

Creare una coda di messaggi - msgget()

La system call msgget ( ) permette di creare una coda di messaggi. Essa accetta due parametri: una chiave di coda e un flag. Il primo parametro, la chiave, può essere un IPC PRIVATE (coda di messaggi privata) oppure un numero intero positivo (scelta migliore qualora la coda da creare fosse pubblica). Il secondo parametro, il flag, è un numero ottale che stabilisce i permessi di lettura, scrittura, esecuzione. Il valore di ritorno della msgget è un valore intero, una chiave che serve ad identificare univocamente la coda creata (se vale -1 significa che la coda non è stata creata).

Esempio

#include <stdio.h>
#include <sys/types.h> // libreria standard per per le strutture V IPC
#include <sys/ipc.h>   // libreria standard per per le strutture V IPC
#include <sys/msg.h>   // libreria per le funzioni specifiche sulle code di msg

// Obiettivo: creazione di una coda di msg privata fornendo potere di accesso al solo //possessore della risorsa

int queue_id = msgget(IPC_PRIVATE, 0600);
if (queue_id == -1)

Struttura del messaggio - struct msgbuf

La struttura 'msgbuf' memorizza un messaggio e consente di fare, successivamente alla propria definizione, accessi in scrittura e lettura dal processo che usa il messaggio.

struct msgbuf ;

Affinchè il corpo del messaggio sia lungo più di 1 byte si alloca più memoria utilizzando la sizeof(struct msgbuf). L'esempio successivo mostra come allocare abbastanza spazio da memorizzare "hello world":

// definizione della stringa "hello world
char* msg_text = "hello world";

// allocazione di un messaggio che abbia abbastanza spazio da contenere la
// stringa e un byte per allocare il carattere terminatore
struct msgbuf* msg =
    (struct msgbuf*)malloc(sizeof(struct msgbuf) + strlen(msg_text));

// settaggio del tipo di messaggio (nell'esempio '1')
msg->mtype = 1;

// inizializzazione del messaggio con la stringa "hello world"
strcpy(msg->mtext, msg_text);

Quando si alloca memoria per l'area text del messaggio è importante allocare 1 byte per memorizzare il carattere NULL (terminatore). Un messaggio può contenere testo oppure dati binari: in quest'ultimo caso è possibile allocare uno spazio pari alla dimensione della struttura msgbuf + almeno 1 byte inoltre, per copiare il messaggio, si userà la funzione memset ( ) e non la strcpy ( ).

Scrittura di un messaggio contenuto in una coda - msgnd ( )

La system call msgsnd ( ) permette di inserire un messaggio in una coda. Essa copia tutte le strutture dei messaggi in fondo alla coda. I parametri che necessita sono:

int msqid - ID relativo alla coda di messaggi (valore ritornato dal msgget ( ));

struct msgbuf* msg - un puntatore alla struttura dei messaggi (vedere sezione precedente);

int msgsz - dimensione del campo data (mtext) del messaggio espressa in bytes;

int msgflg - flag che specifica la modalità di spedizione del messaggio (zero se si vuole spedire il msg subito, IPC NOWAIT se non è possibile spedire subito il msg senza interrompere il processo, il cui valore di ritorno è -1).

int rc = msgsnd(queue_id, msg, strlen(msg_text)+1, 0);

if (rc == -1)

Lettura di un messaggio contenuto in una coda - msgrcv ( )

Per leggere un messaggio da una coda si usa la system call msgrcv che ha i seguenti parametri:

int msqid - ID relativo alla coda di messaggi (valore ritornato dal msgget ( ));

struct msgbuf* msg - un puntatore preallocato alla struttura msgbuf;

int msgsz - dimensione del campo data (mtext) del messaggio espressa in bytes da ricevere(non deve essere più grande dello spazio allocato per il campo text in msg;

int msgtyp - Tipo del messaggio da leggere (0 ritorna il primo messaggio nella coda, un intero positivo: ritorna il primo messaggio della coda avente mtype uguale al numero dato; un intero negativo: ritorna il primo messaggio il cui valore è uguale o minore al valore assoluto del numero negativo);

int msgflg - a logical 'or' combination of any of the following flags:

• IPC_NOWAIT - if there is no message on the queue matching what we want to read, return '-1', and set errno to ENOMSG
• MSG_EXCEPT - if the message type parameter is a positive integer, then return the first message whose type is NOT equal to the given integer.
• MSG_NOERROR - If a message with a text part larger then 'msgsz' matches what we want to read, then truncate the text when copying the message to our msgbuf structure. If this flag is not set and the message text is too large, the system call returns '-1', and errno is set to E2BIG

Esempio di lettura di un messaggio dalla coda:

// preparazione della msg structure larga tanto da poter contenere "hello world"

struct msgbuf* recv_msg =

(struct msgbuf*)malloc(sizeof(struct msgbuf)+strlen("hello world"));

// uso di msgrcv() per leggere il messaggio. Siccome va bene qualsiasi tipo

// uso '0' come parametro type e non uso nessun flag (flag=0).

int rc = msgrcv(queue_id, recv_msg, strlen("hello world")+1, 0, 0);

if (rc == -1)

N.B: se la dimensione del campo data è maggiore di strlen("hello world")+1 allora si verificherebbe un errore; se non c'è un messaggio nella coda, ala chiamata a msgrcv()potrebbe bloccare il processo finchè: 1- viene messo un messaggio nella coda; 2- la coda viene rimossa following happens; 3- il processo riceve un segnale).

Esempi

queue_sender.c = Crea una coda di messaggi pubblica che viene usata per inviare messaggi con differenti priorità. queue_reader.c = Legge i messaggi su una coda e, tramite essi, esegue qualcosa (nell'esempio stampa il loro contenuto su video). Sulla linea di comando viene passato un numero che rappresenta la priorità del messaggio da leggere.