POSIX和SYSTEM的消息队列应该注意的有关问题

/**************************************************************************************************/
消息队列部分
消息队列
消息队列可以认为是一个消息链表。有足够写权限的线程就可往队列中放置消息，有足够读权限的线程就可以从队列中取走消息。每个消息是一个记录，他有发送者赋予一个优先级。在某个进程往一个队列写入消息之前，并不需要另外某个进程在该队列上等待消息的到达。
Posix消息队列和System V系统的消息队列区别：
1、 对Posix消息队列的读总是返回最高优先级的最早消息，对System V消息队列得读则可以返回任意指定优先级的消息
2、 当往一个队列放置一个消息时，Posix消息队列允许产生一个信号或启动一个线程，System V消息队列则不提供类似的机制
消息的属性：
1、 一个无符号整数优先级（Posix）或是长整类型（SystemV）
2、 消息的数据部分长度
3、 数据本身
(System V系统发送消息时需要定义消息的结构，而Posix系统不需要定义这样的结构)
Posxi 消息队列
mq_open   创建一个新消息队列或是打开一个已经存在的消息队列，返回值成为消息队列描述字。
mq_close   关闭已打开的消息队列。
mq_unlink   从系统删除消息队列。
每个消息队列有四个属性，有mq_getattr获得这些属性，mq_setattr设置其中某个属性
   mq_send：用于往一个队列中放置一个消息
   mq_receive：用于往一个队列中取走一个消息,该函数总是返回所指定队列中最高优先级的最早的消息，而且该优先级能随该消息的内容及长度一同返回。
每个消息有一个优先级，他是一个小于MQ_PRIO_MAX的无符号整数，Posix要求这个上限至少为32 。
mq_notify 该函数给指定队列建立或删除异步事件通知
int mq_notify(mqd_t mqdes ,const struct sigevent *notification);
使用规则：
1、 如果notification参数非空，那么当前进程希望在有一个消息到达所指定队列而且该队列先前为空时得到通知。我们说该进程被注册为接收该队列的通知
2、 如果notification参数为空指针，而且当前进程目前被注册为接收所指定队列的通知，那么现有注册将被撤销。
3、 任意时刻只有一个进程可以被注册为接收某个给定队列的通知。
4、 当有一个消息到达某个先前为空的队列，而且已有一个进程被注册为接收该队列的通知时，只有没有任何进程阻赛在该队列的mq_receive调用的前提下，通知才会发生。这就是说，在mq_revcive调用中的阻赛比任何通知的注册都优先。
5、 当该通知被发送给他的注册进程时，其注册即被撤销，该进程必须再次调用该函数以重新注册。
(当消息队列有消息来到时该函数产生一个信号或时线程，信号或线程是由struct sigevent 参数指定的)
System V 的消息队列
   System V消息队列使用消息队列标示符标示。具有足够特权的任何进程都可以往一个队列放置一个消息，具有足够特权的任何进程都可以从一个给定队列读出一个消息。
对于系统中的每个消息队列，内核维护一个信息结构，struct msqid_ds
msgget函数用于创建一个新的消息队列或访问一个已经存在的消息队列msgget(key_t key ,int oflag )，在创健一个新消息队列时，msqid_ds结构将被初始化。
msgsnd函数往msgget函数建立的消息队列中放置一个消息，
msgsnd(int msqid,const void * ptr,size_t length,int flag);其中ptr是一个结构指针，该结构具有如下的模板struct msgbuf{long mtype ; char mtext[1]}; 该模板可以在<sys/msg.h>;中找到
其中消息类型必须大于0，msgbuf 结构定义中的名字mtext不大确切；消息的数据部分并不局限于文本，任何形式的数据都是允许的，无论是二进制数据还是文本。内核根本不解释消息数据的内容。使用模板的说法描述这个结构，因为ptr所指向的只是一个含有消息类型的长整数，消息本身则紧跟在他之后。不过大多数应用并不使用msgbuf结构的这个定义，因为其数据量通常是不够的。大多数应用定义自己的消息结构，其数据部分根据应用的需要定义。例如：应用需要交换由一个16位整数后跟一个8字节字符数组构成的消息，那么它的结构如下：typedef struct my_msgbuf{ long mytype ; int16_t mshort; char mchar[8];} 
msgsnd 的length参数以字节为单位指定代发送消息的长度。这是位于长整数消息类型之后的用户自定义数据的长度。该长度可以是0。如上例长度为 sizeof(struct my_msgbuf)-sizeof(long).
msgrcv（int msqid,void *ptr ,size_t length,long type ,int flag）函数中ptr参数指定所接受消息的存放位置。和msgsnd一样，该指针指向紧挨在真正的消息数据之前返回的长整数类型字段(就是定义的消息结构体)。Length指定由ptr指向的缓冲区中数据部分的大小。这是该函数能返回的最大数据量。该长度不包括长整数类型字段。Type指定希望从所给定的队列中读出什么样的消息：
如果type为0，那就返回该队列中的第一个消息。
如果type大于0，那就返回其类型值为type的第一个消息。
如果type小于0，那就返回其类型值小于或等于type参数的绝对值的消息中类型值得最小的第一个消息。
Msgrcv的flag参数指定所请求类型的消息不在所指定的队列中时怎么办。成功返回时，msgrcv返回所接收消息中数据的字节数。他不包括也通过ptr参数返回的长整数消息类型所需的几个字节。
Msgctl函数提供在一个消息队列上的各种控制操作。Msgctl(int msqid ,int cmd ,struct msqid_de *buff);
三个命令:IPC_RMID 从系统删除指定的消息队列；
IPC_SET 给所指定的消息队列设置其msqid_ds结构的成员；
IPC_STAT 给调用者返回对应所指定消息队列的当前msqid_ds结构

POSIX和SYSTEM的消息队列应该注意的问题

首先看看POSIX的代码：

1.posix_mq_server.c

#include <mqueue.h>
#include <sys/stat.h>
#include <string.h>
#include <stdio.h>
#define MQ_FILE "/mq_test"
#define BUF_LEN 128

int main()
{
    mqd_t mqd;
    struct mq_attr attr;
    char buf[BUF_LEN + 1] = "quit";
    int cnt;
    int  por = 0;
    attr.mq_flags = 0;
    attr.mq_maxmsg = 128;
    attr.mq_msgsize = 128;
    attr.mq_curmsgs = 0;
    //mqd = mq_open(MQ_FILE, O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR, NULL);
    mqd = mq_open(MQ_FILE, O_RDONLY | O_CREAT, 0644, &attr);
    if (-1 == mqd)
    {
        printf("mq_open error.\n");
        return -1;
    }

    do{
        cnt = mq_receive(mqd, buf, BUF_LEN, &por);
        if (0 < cnt)
        {
            printf("mq receive : ");
            fflush(stdout);
            buf[cnt] = '\0';
            printf("%s  por:%d\n", buf,por);
        }

    }while(strcmp(buf, "quit"));

    printf("\n");
    mq_close(mqd);
    mq_unlink(MQ_FILE);

    return 0;
}
2.posix_mq_client.c

#include <mqueue.h>
#include <sys/stat.h>
#include <string.h>
#include <stdio.h>
#define MQ_FILE "/mq_test"
#define BUF_LEN 128

int main()
{
    mqd_t mqd;
    struct mq_attr attr;
    char buf[BUF_LEN + 1] = "quit";
    int cnt;
    int  por = 0;
    attr.mq_flags = 0;
    attr.mq_maxmsg = 128;
    attr.mq_msgsize = 128;
    attr.mq_curmsgs = 0;
    //mqd = mq_open(MQ_FILE, O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR, NULL);
    mqd = mq_open(MQ_FILE, O_RDONLY | O_CREAT, 0644, &attr);
    if (-1 == mqd)
    {
        printf("mq_open error.\n");
        return -1;
    }

    do{
        cnt = mq_receive(mqd, buf, BUF_LEN, &por);
        if (0 < cnt)
        {
            printf("mq receive : ");
            fflush(stdout);
            buf[cnt] = '\0';
            printf("%s  por:%d\n", buf,por);
        }

    }while(strcmp(buf, "quit"));

    printf("\n");
    mq_close(mqd);
    mq_unlink(MQ_FILE);

    return 0;
}

3.makefile

target:client  server
client: posix_mq_client.c
    gcc posix_mq_client.c -o client -lrt
server:posix_mq_server.c
    gcc posix_mq_server.c -o server -lrt

clean:
    rm -f client server
    rm -f *.o

运行make：

==[]==root@gaoke:~/code$./server 
MQ_MSG : fgsdfgsdfgsdfg
MQ_POR : 9
MQ_MSG : dfgsdfgsdfg
MQ_POR : 3
MQ_MSG : dfghsdfhgjghdj
MQ_POR : 6
MQ_MSG : sdfgdgfhgjh
MQ_POR : 2
MQ_MSG : dsfghgjghjkh
MQ_POR : 8
MQ_MSG : sdfgsdfgsdfgsd
MQ_POR : 5
MQ_MSG : 

==[]==root@gaoke:~/code$./client 
mq receive : fgsdfgsdfgsdfg  por:9
mq receive : dsfghgjghjkh  por:8
mq receive : dfghsdfhgjghdj  por:6
mq receive : sdfgsdfgsdfgsd  por:5
mq receive : dfgsdfgsdfg  por:3
mq receive : sdfgdgfhgjh  por:2
我们发现POSIX是严格按照优先级排序读出的，而且先读出作业优先级最高的作业。

好了再看看我们的SYSTEM是如何进行的，先写个简单的代码调试运行看看结果如何：

首先我先说明一下System V系统的消息对列对象结构：

01 02 03 04 05 06 07 08 09 10 11 12 13

struct msqid_ds {      struct ipc_perm     msg_perm;   // 权限，跟共享内存一样      struct msg      *msg_first;  // 指向队列的第一条消息      struct msg      *msg_last;   // 指向队列的最后一条消息      msglen_t        msg_cbytes;  // 当前队列所占字节数      msgnum_t        msg_qnum;    // 当前队列的消息数      msglen_t        msg_qbytes;  // 队列允许的最大字节数      pid_t           msg_lspid;   // 最后调用msgsnd的PID      pid_t           msg_lrpid;   // 最后调用msgrcv的PID      time_t          msg_stime;   // 最后调用msgsnd的时间      time_t          msg_rtime;   // 最后调用msgrcv的时间      time_t          msg_ctime;   // 最后调用msgctl的时间 }

使用其中一个IPC机制时，系统内核会维护一个ipc权限对象，用于设置读写权限

1 2 3 4 5 6 7 8 9

struct ipc_perm {      uid_t   uid;     // owner’s user id      gid_t   gid;         // owner’s group id      uid_t   cuid;        // creator’s user id      gid_t   cgid;        // creator’s group id      mode_t  mode;    // 读写权限      ulong_t seq;         // 序列号      key_t   key;         // IPC key ｝

 

1.sys_msq_server.c

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define MQ_FILE "./mq_test"
#define BUF_LEN 128
struct msgbuf {
   long mtype;     /*  message type, must be > 0 */
   char mtext[256];  /*  message data */
};
int  main()
{
    struct msqid_ds info={0};
    struct msgbuf MSG={0};
    key_t key = ftok(MQ_FILE,10);
    int cnt =  msgget(key,IPC_CREAT|0666);//0：取消息队列标识符，若不存在则函数会报错IPC_CREAT：当msgflg&IPC_CREAT为真时，如果内核中不存在键值与key相等的消息队列，则新建一个消息队列；如果存在这样的消息队列，返回此消息队列的标识符IPC_CREAT|IPC_EXCL：如果内核中不存在键值与key相等的消息队列，则新建一个消息队列；如果存在这样的消息队列则报错
    if(cnt == -1)
    {
        perror("error!");
    }
    while(1){
        printf("enter the MSG:\n");
        scanf("%s",MSG.mtext);
        MSG.mtype = 1;
        //

        msgsnd(cnt,&MSG,strlen(MSG.mtext)+1,IPC_NOWAIT);// 最后一个参数：0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列IPC_NOWAIT：当消息队列已满的时候，msgsnd函数不等待立即返回IPC_NOERROR：若发送的消息大于size字节，则把该消息截断，截断部分将被丢弃，且不通知发送进程
        msgctl(cnt,IPC_STAT,&info);//IPC_STAT:获得msgid的消息队列头数据到buf中IPC_SET：设置消息队列的属性，要设置的属性需先存储在buf中，可设置的属性包括：msg_perm.uid、msg_perm.gid、msg_perm.mode以及msg_qbytes

        printf("uid:%d, gid = %d, cuid = %d, cgid= %d\n" , info.msg_perm.uid,  info.msg_perm.gid,  info.msg_perm.cuid,  info.msg_perm.cgid  ) ;
        printf("read-write:%03o, cbytes = %lu, qnum = %lu, qbytes= %lu\n" , info.msg_perm.mode&0777, info.msg_cbytes, info.msg_qnum, info.msg_qbytes ) ;
        system("ipcs -q");
    }
}

 

2.sys_msq_client.c

#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <mqueue.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define MQ_FILE "./mq_test"
#define BUF_LEN 128
struct msgbuf {
   long mtype;     /*  message type, must be > 0 */
   char mtext[256];  /*  message data */
};
int  main()
{
    struct msqid_ds info={0};
    struct msgbuf MSG={0};
    key_t key = ftok(MQ_FILE,10);
    int cnt =  msgget(key,IPC_CREAT|0666);
    int size =0;
    if(cnt == -1)
    {
        perror("error!");
    }
    while(1){
        size = msgrcv(cnt,&MSG,256,1,IPC_NOWAIT);
        if(size > 0)
        {
               puts(MSG.mtext);
        msgctl(cnt,IPC_STAT,&info);
        printf("uid:%d, gid = %d, cuid = %d, cgid= %d\n" ,info.msg_perm.uid,  info.msg_perm.gid,  info.msg_perm.cuid,  info.msg_perm.cgid  ) ;
        printf("read-write:%03o, cbytes = %lu, qnum = %lu, qbytes= %lu\n" , info.msg_perm.mode&0777, info.msg_cbytes, info.msg_qnum, info.msg_qbytes ) ;
        }
    }
}
3.makefile

target:client  server
client: sys_msq_client.c
    gcc sys_msq_client.c -o client -lrt
server:sys_msq_server.c
    gcc sys_msq_server.c -o server -lrt

clean:
    rm -f client server
    rm -f *.o

然后make运行

==[]==root@gaoke:~/code$./server 
enter the MSG:
aaaa
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 5, qnum = 1, qbytes= 65536

------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0xffffffff 0          root       666        5            1          

enter the MSG:
dddd
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 10, qnum = 2, qbytes= 65536

------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0xffffffff 0          root       666        10           2          

enter the MSG:
fffff
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 16, qnum = 3, qbytes= 65536

------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0xffffffff 0          root       666        16           3          

enter the MSG:
ggggg
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 22, qnum = 4, qbytes= 65536

------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0xffffffff 0          root       666        22           4           

 ==[]==root@gaoke:~/code$./client 
asdfasdfas
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 0, qnum = 0, qbytes= 65536
asdfasdfasdf
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 0, qnum = 0, qbytes= 65536
ssss
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 0, qnum = 0, qbytes= 65536

==[]==root@gaoke:~/code$./client 
aaaa
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 17, qnum = 3, qbytes= 65536

dddd
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 12, qnum = 2, qbytes= 65536
fffff
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 6, qnum = 1, qbytes= 65536
ggggg
uid:0, gid = 0, cuid = 0, cgid= 0
read-write:666, cbytes = 0, qnum = 0, qbytes= 65536
由此我们还发现了什么呢？有没有发现SYSTEM的消息输入长度是固定的，然而POSIX的是可变长的。

 

SYSTEM的消息队列函数由msgget、msgctl、msgsnd、msgrcv四个函数组成。下面的表格列出了这四个函数的函数原型及其具体说明。

1.   msgget函数原型

msgget(得到消息队列标识符或创建一个消息队列对象)
所需头文件	#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
函数说明	得到消息队列标识符或创建一个消息队列对象并返回消息队列标识符
函数原型	int msgget(key_t key, int msgflg)
函数传入值	key	0(IPC_PRIVATE)：会建立新的消息队列
		大于0的32位整数：视参数msgflg来确定操作。通常要求此值来源于ftok返回的IPC键值
	msgflg	0：取消息队列标识符，若不存在则函数会报错
		IPC_CREAT：当msgflg&IPC_CREAT为真时，如果内核中不存在键值与key相等的消息队列，则新建一个消息队列；如果存在这样的消息队列，返回此消息队列的标识符
		IPC_CREAT|IPC_EXCL：如果内核中不存在键值与key相等的消息队列，则新建一个消息队列；如果存在这样的消息队列则报错
函数返回值	成功：返回消息队列的标识符
	出错：-1，错误原因存于error中
附加说明	上述msgflg参数为模式标志参数，使用时需要与IPC对象存取权限（如0600）进行|运算来确定消息队列的存取权限
错误代码	EACCES：指定的消息队列已存在，但调用进程没有权限访问它 EEXIST：key指定的消息队列已存在，而msgflg中同时指定IPC_CREAT和IPC_EXCL标志 ENOENT：key指定的消息队列不存在同时msgflg中没有指定IPC_CREAT标志 ENOMEM：需要建立消息队列，但内存不足 ENOSPC：需要建立消息队列，但已达到系统的限制

如果用msgget创建了一个新的消息队列对象时，则msqid_ds结构成员变量的值设置如下：

Ÿ        msg_qnum、msg_lspid、msg_lrpid、 msg_stime、msg_rtime设置为0。

Ÿ        msg_ctime设置为当前时间。

Ÿ        msg_qbytes设成系统的限制值。

Ÿ        msgflg的读写权限写入msg_perm.mode中。

Ÿ        msg_perm结构的uid和cuid成员被设置成当前进程的有效用户ID，gid和cuid成员被设置成当前进程的有效组ID。

2.   msgctl函数原型

msgctl (获取和设置消息队列的属性)
所需头文件	#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
函数说明	获取和设置消息队列的属性
函数原型	int msgctl(int msqid, int cmd, struct msqid_ds *buf)
函数传入值	msqid	消息队列标识符
	cmd	IPC_STAT:获得msgid的消息队列头数据到buf中
		IPC_SET：设置消息队列的属性，要设置的属性需先存储在buf中，可设置的属性包括：msg_perm.uid、msg_perm.gid、msg_perm.mode以及msg_qbytes
		buf：消息队列管理结构体，请参见消息队列内核结构说明部分
函数返回值	成功：0
	出错：-1，错误原因存于error中
错误代码	EACCESS：参数cmd为IPC_STAT，确无权限读取该消息队列 EFAULT：参数buf指向无效的内存地址 EIDRM：标识符为msqid的消息队列已被删除 EINVAL：无效的参数cmd或msqid EPERM：参数cmd为IPC_SET或IPC_RMID，却无足够的权限执行

3.   msgsnd函数原型

msgsnd (将消息写入到消息队列)
所需头文件	#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
函数说明	将msgp消息写入到标识符为msqid的消息队列
函数原型	int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)
函数传入值	msqid	消息队列标识符
	msgp	发送给队列的消息。msgp可以是任何类型的结构体，但第一个字段必须为long类型，即表明此发送消息的类型，msgrcv根据此接收消息。msgp定义的参照格式如下：     struct s_msg{ /*msgp定义的参照格式*/      long type; /* 必须大于0,消息类型 */            char mtext[256]; /*消息正文，可以是其他任何类型*/     } msgp;
	msgsz	要发送消息的大小，不含消息类型占用的4个字节,即mtext的长度
	msgflg	0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列
		IPC_NOWAIT：当消息队列已满的时候，msgsnd函数不等待立即返回
		IPC_NOERROR：若发送的消息大于size字节，则把该消息截断，截断部分将被丢弃，且不通知发送进程。
函数返回值	成功：0
	出错：-1，错误原因存于error中
错误代码	EAGAIN：参数msgflg设为IPC_NOWAIT，而消息队列已满 EIDRM：标识符为msqid的消息队列已被删除 EACCESS：无权限写入消息队列 EFAULT：参数msgp指向无效的内存地址 EINTR：队列已满而处于等待情况下被信号中断 EINVAL：无效的参数msqid、msgsz或参数消息类型type小于0

   msgsnd()为阻塞函数，当消息队列容量满或消息个数满会阻塞。消息队列已被删除，则返回EIDRM错误；被信号中断返回E_INTR错误。

 如果设置IPC_NOWAIT消息队列满或个数满时会返回-1，并且置EAGAIN错误。

msgsnd()解除阻塞的条件有以下三个条件：

①    不满足消息队列满或个数满两个条件，即消息队列中有容纳该消息的空间。

②    msqid代表的消息队列被删除。

③    调用msgsnd函数的进程被信号中断。

4.   msgrcv函数原型

msgrcv (从消息队列读取消息)
所需头文件	#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h>
函数说明	从标识符为msqid的消息队列读取消息并存于msgp中，读取后把此消息从消息队列中删除
函数原型	ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,                       int msgflg);
函数传入值	msqid	消息队列标识符
	msgp	存放消息的结构体，结构体类型要与msgsnd函数发送的类型相同
	msgsz	要接收消息的大小，不含消息类型占用的4个字节
	msgtyp	0：接收第一个消息
		>0：接收类型等于msgtyp的第一个消息
		<0：接收类型等于或者小于msgtyp绝对值的第一个消息
	msgflg	0: 阻塞式接收消息，没有该类型的消息msgrcv函数一直阻塞等待
		IPC_NOWAIT：如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG
		IPC_EXCEPT：与msgtype配合使用返回队列中第一个类型不为msgtype的消息
		IPC_NOERROR：如果队列中满足条件的消息内容大于所请求的size字节，则把该消息截断，截断部分将被丢弃
函数返回值	成功：实际读取到的消息数据长度
	出错：-1，错误原因存于error中
错误代码	E2BIG：消息数据长度大于msgsz而msgflag没有设置IPC_NOERROR EIDRM：标识符为msqid的消息队列已被删除 EACCESS：无权限读取该消息队列 EFAULT：参数msgp指向无效的内存地址 ENOMSG：参数msgflg设为IPC_NOWAIT，而消息队列中无消息可读 EINTR：等待读取队列内的消息情况下被信号中断

msgrcv()解除阻塞的条件有以下三个：

①    消息队列中有了满足条件的消息。

②    msqid代表的消息队列被删除。

③    调用msgrcv()的进程被信号中断。