10.2 消息队列实现的回射服务器

模型如下：

服务器：

#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) 
        do 
        { 
                perror(m); 
                exit(EXIT_FAILURE); 
        } while(0)


#define MSGMAX 8192
struct msgbuf {
    long mtype;       /* message type, must be > 0 */
    char mtext[MSGMAX];    /* message data */
};


void echo_srv(int msgid)
{
    int n;
    struct msgbuf msg;
    memset(&msg, 0, sizeof(msg));
    while (1)
    {
        if ((n = msgrcv(msgid, &msg, MSGMAX, 1, 0)) < 0)
            ERR_EXIT("msgsnd");
        
        int pid;
        pid = *((int*)msg.mtext);

        fputs(msg.mtext+4, stdout);
        msg.mtype = pid;
        msgsnd(msgid, &msg, n, 0);
    }
}

int main(int argc, char *argv[])
{
    int msgid;
    msgid = msgget(0x1234, IPC_CREAT | 0666);
    if (msgid == -1)
        ERR_EXIT("msgget");

    echo_srv(msgid);

    return 0;
}

客户端：

#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#define ERR_EXIT(m) 
        do 
        { 
                perror(m); 
                exit(EXIT_FAILURE); 
        } while(0)

#define MSGMAX 8192
struct msgbuf {
    long mtype;       /* message type, must be > 0 */
    char mtext[MSGMAX];    /* message data */
};

//思路：
//客户端发给服务器消息类型总是1
//服务器端回给客户端的type是对方进程号
//相当于服务器端 从消息队列中收消息，然后服务器端分类型回复客户端（通过消息队列）


//n个进程通过消息队列进行交换
//有没有产生死锁的可能
//n个客户端向服务器发送消息（本质上是向内核消息队列发送消息），若消息队列满了；服务区回射涵时，会阻塞。。造成程序死锁
//即使，非阻塞。。。仍然回阻塞。。

void echo_cli(int msgid)
{
    int n;
    int pid;
    pid = getpid();
    struct msgbuf msg;
    memset(&msg, 0, sizeof(msg));
    
    //消息内容由：自己的pid+键盘输入
    *((int*)msg.mtext) = pid;
    //消息类型 1
    msg.mtype = 1;
    
    while (fgets(msg.mtext+4, MSGMAX, stdin) != NULL)
    {
        if (msgsnd(msgid, &msg, 4+strlen(msg.mtext+4), 0) < 0)
            ERR_EXIT("msgsnd");

        //前四个字节是自己的pid，就不清空了。
        memset(msg.mtext+4, 0, MSGMAX-4);
        if ((n = msgrcv(msgid, &msg, MSGMAX, pid, 0)) < 0)
                        ERR_EXIT("msgsnd");

        fputs(msg.mtext+4, stdout);
        memset(msg.mtext+4, 0, MSGMAX-4);
    }
}

int main(int argc, char *argv[])
{
    int msgid;
    msgid = msgget(0x1234, 0);
    if (msgid == -1)
        ERR_EXIT("msgget");

    echo_cli(msgid);
    return 0;
}

 这个模型下所有进程统一通过队列通信，队列的大小有限制，而且这些进程既从这个队列读又往这个队列写，操作时无序的，很容易造成队列满或者队列空，所以当进程数很多时容易发生阻塞。

可以改进为如下的模型：

每来一个客户端，就fork一个进程，让这个进程和客户端通信。

监控模型：每一个客户端进程是一个监控模块，将监控到的消息统一发给一个总服务进程，然后这个总服务进程开一个端口统一发给外部。这里说的客户端进程和总服务进程是在一个机器上的。