¿Cómo comprobar si hay una cola de mensajes en Linux?
#incluye
#incluye
#incluye tipo.
& gt
# incluir msg.h & gt
#include
# incluir ipc.h & gt
void msg_show_attr(int msg_id, struct msqid_ds msg_info)
{
int ret =-1;
dormir(1);
ret = msgctl( msg_id, IPC_STAT y ampmsg_info);
if( -1 == ret)
{
Printf(No se puede obtener la información del mensaje\n); /p>
Regresar;
}
printf(\n);
Printf(byte de cola actual: %d\n, msg _ info . msg _ cbytes);
Printf (número de mensajes en cola: %d\n, msg _ info . msg _ qnum
Printf (bytes en cola: %d \n); , msg_info. msg_q bytes);
Printf (PID del proceso de envío de mensajes: % d \n, msg_info. msg_LSP ID);
Printf (PID del proceso de recepción de mensajes: % d\n , msg_info.msg_lrpid);
Printf (enviando mensaje entre: %s,ctime(&(msg_info.msg_stime) ));
Printf(entre recibiendo mensajes: % s, ctime (&(msg_info.msg_rtime)));
Printf(entre cambios: % s, ctime(&(msg_info.msg_ctime)));
Printf(uid del mensaje:% d \n, msg_info.msg_perm.uid);
Printf(Mensaje GID: % d\n, msg_info.msg_perm.GID);
}
int main(void)
{
int ret =-1;
int message_flag, message_id
key_t clave;
Estructura msgmbuf {
int mtype
char mtext[10];
};
struct msqid _ ds msg _ info
struct msgmbuf msg _ mbuf
int msg_sflags, msg _ rflags
char * msg path =/IPC/msg/;
clave = ftok( msgpath, 'a');
if (clave! = -1)
{
Printf(clave de configuración de trabajo\n);
}
Otros
{
Printf(Error al crear la clave\n);
}
msg_flags = IPC_CREAT
msg_id = msgget(clave, msg_flags|0666);
if(-1 == msg_id)
{
Printf(Error al crear el mensaje\n) ;
Devuelve 0;
}
msg_show_attr(m
sg_id, msg_info);
msg_sflags = IPC_NOWAIT
msg_mbuf.mtype = 10;
Memcpy(msg_mbuf.mtext, mensaje de prueba, tamaño de);
ret = msgsnd(msg_id, & ampMsg_mbuf, sizeof(mensaje de prueba), msg_sflags);
if( -1 == ret)
{
Printf(Error al enviar el mensaje\n);
}
msg_show_attr(msg_id, msg_info);
MSG_r flags = IPC_NOWAIT | MSG_no error;
ret = msgrcv(msg_id, & ampmsg_mbuf, 10, 10
* * *Disfruta del código de muestra de memoria:
#include
# incluir sem.h & gt
# incluir ipc.h & gt
#include
typedef int SEM_t;
federación sindical
int val
struct semid_ds * buf
Matriz corta* sin firmar;
} arg
sem_t CreateSem( key_t clave, int valor)
{
alianza semun sem
sem _ t semid
sem.val = valor;
semi = SEM get(clave, valor, IPC _ CREAT | 0666);
if(-1 == semi)
{
printf(crear error de semáforo\n);
return-1;
}
SEM CTL(semi, 0, SETVAL, SEM);
Retorno semid
}
/*
Estructura sembuf{
ushort sem _ num
short sem _ op
short sem _ flg
};
*/
void SetvalueSem(SEM_t semi, valor int )
{
Alianza semun sem
sem.val = valor
SEM CTL(semi, 0, SETVAL, SEM)
Retorno;
}
int GetvalueSem(SEM_t semi)
{
Alianza semun sem<; /p>
Volver a SEM CTL(semi, 0, GETVAL, SEM);
Volver a sem.val
}
Destrucción de poros SEM ( SEM_t semi)
{
Alianza semun sem
SEM val = 0
SEM CTL(semi, 0, IPC_RMID,. SEM);
}
int Sem _ P(Sem _ t semi)
{
struct sembuf sops={0, +1, IPC _ NOWAIT };
Return (semop(semi d &sops,1));
<p>}
int Sem_V
{
struct sembuf sops={0, -1, IPC _ NOWAIT };
Regresar (semop(semi d & sops, 1));
}
static char msg[]=***disfrutar de la memoria\n;
int main (void)
{
key_t key;
int semid, shmid
char i, *shms, *shmc
struct semid _ ds buf
int valor = 0;
Buffer de carga[80];
PID _ t p;
p>
key = ftok(/ipc/sem/, 'a');
shmid = shmget(key, 1024, IPC_CREAT|0604);
semi = CreateSem(clave, 1);
p = fork();
if (p & gt0)
{
/ *Proceso principal*/
/*Crear* * *Memoria compartida*/
shms = (char *)shmat(shmid, 0, 0);
memcpy(shms,msg,strlen(msg)+1);
dormir(10);
SEM_P(semi);
shm dt (shms );
DestroySem(semi);
}
si no(p == 0)
{
shmc = (char *)shmat(shmid, 0, 0);
SEM _ V(semi
Printf(***Valor de memoria: %s \n); ,shmc);
shmdt(sg_