Red de conocimiento informático - Material del sitio web - ¿Cómo comprobar si hay una cola de mensajes en Linux?

¿Cómo comprobar si hay una cola de mensajes en Linux?

#incluye

#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_