TCP服务器将Receive消息返回给C中除发送方之外的所有客户端

这是我的密码

服务器.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <mqueue.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

#define PORT 4444
#define BUF_SIZE 2000
#define CLADDR_LEN 100

void main() {
    struct sockaddr_in addr, cl_addr;
    int sockfd, len, ret, newsockfd,clientnumber;
    char buffer[BUF_SIZE];
    pid_t childpid;
    char clientAddr[CLADDR_LEN];


    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        printf("Error creating socket!\n");
        exit(1);
    }
    printf("Socket created...\n");

    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = PORT;

    ret = bind(sockfd, (struct sockaddr *) &addr, sizeof(addr));
    if (ret < 0) {
        printf("Error binding!\n");
        exit(1);
    }
    printf("Binding done...\n");
    clientnumber = 0;
    printf("Waiting for a connection...\n");
    listen(sockfd, 5);

    for (;;) { //infinite loop
        len = sizeof(cl_addr);
        newsockfd = accept(sockfd, (struct sockaddr *) &cl_addr, &len);
        if (newsockfd < 0) {
            printf("Error accepting connection!\n");
            exit(1);
        }
        printf("Connection accepted...\n");
        clientnumber++;
        inet_ntop(AF_INET, &(cl_addr.sin_addr), clientAddr, CLADDR_LEN);
        if ((childpid = fork()) == 0) { //creating a child process

            close(sockfd);
            //stop listening for new connections by the main process.
            //the child will continue to listen.
            //the main process now handles the connected client.


            sprintf(buffer, "USER%d", clientnumber);
            ret = sendto(newsockfd, buffer, BUF_SIZE, 0, (struct sockaddr *) &cl_addr, len);
            if (ret < 0){
                printf("Allocate Client number error\n");
                exit(1);
            }else{
                printf("Passing Client number : %d to Client Address %s ,  Newsockfd : %d ,claddr %d : \n",clientnumber,clientAddr,newsockfd,cl_addr);

            }


            for (;;) {
                memset(buffer, 0, BUF_SIZE);
                ret = recvfrom(newsockfd, buffer, BUF_SIZE, 0, (struct sockaddr *) &cl_addr, &len);
                if(ret < 0) {
                    printf("Error receiving data! from %s\n",clientAddr);
                    exit(1);
                }

                printf("Received data from %s(%d): %s\n", clientAddr,cl_addr.sin_addr.s_addr, buffer);


                ret = sendto(newsockfd, buffer, BUF_SIZE, 0, (struct sockaddr *) &cl_addr, len);
                if (ret < 0) {
                    printf("Error sending data! to %s\n",clientAddr);
                    exit(1);
                }
                printf("Sent data to %s: %s   Newsockfd : %d ,claddr %d :\n", clientAddr, buffer,newsockfd,cl_addr);

            }


        }
        close(newsockfd);
    }
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义端口4444
#定义BUF_尺寸2000
#定义CLADDR_LEN 100
void main（）{
地址中的结构sockaddr\u，cl\u addr；
int sockfd、len、ret、newsockfd、clientnumber；
字符缓冲区[BUF_大小]；
pid_t childpid；
char clientAddr[CLADDR_LEN]；
sockfd=套接字（AF_INET，SOCK_STREAM，0）；
if（sockfd<0）{
printf（“创建套接字时出错！\n”）；
出口（1）；
}
printf（“已创建套接字…\n”）；
memset（&addr，0，sizeof（addr））；
addr.sin_family=AF_INET；
addr.sin\u addr.s\u addr=INADDR\u ANY；
addr.sinu端口=端口；
ret=bind（sockfd，（struct sockaddr*）&addr，sizeof（addr））；
如果（ret<0）{
printf（“错误绑定！\n”）；
出口（1）；
}
printf（“绑定完成…\n”）；
clientnumber=0；
printf（“正在等待连接…\n”）；
听（sockfd，5）；
对于（；）{//无限循环
len=sizeof（cl_addr）；
newsockfd=accept（sockfd，（结构sockaddr*）和cl_addr，&len）；
if（newsockfd<0）{
printf（“接受连接时出错！\n”）；
出口（1）；
}
printf（“已接受连接…\n”）；
clientnumber++；
内部地址（自动内部地址和（客户地址、分类地址）；
如果（（childpid=fork（））==0）{//正在创建子进程
关闭（sockfd）；
//停止侦听主进程的新连接。
//孩子会继续听。
//主进程现在处理连接的客户端。
sprintf（缓冲区，“用户%d”，客户端号）；
ret=sendto（newsockfd，buffer，BUF_SIZE，0，（struct sockaddr*）和cl_addr，len）；
如果（ret<0）{
printf（“分配客户端号码错误\n”）；
出口（1）；
}否则{
printf（“将客户端号码：%d传递到客户端地址%s，Newsockfd:%d，claddr%d:\n”，客户端号码，客户端地址，Newsockfd，cl\u地址）；
}
对于（；；）{
memset（缓冲区，0，BUF_大小）；
ret=recvfrom（newsockfd，buffer，BUF_SIZE，0，（struct sockaddr*）和cl_addr，&len）；
如果（ret<0）{
printf（“从%s接收数据时出错”，clientAddr）；
出口（1）；
}
printf（“从%s（%d）接收的数据）：%s\n”，clientAddr，cl\u addr.sin\u addr.s\u addr，buffer）；
ret=sendto（newsockfd，buffer，BUF_SIZE，0，（struct sockaddr*）和cl_addr，len）；
如果（ret<0）{
printf（“将数据发送到%s\n”客户端地址时出错）；
出口（1）；
}
printf（“已将数据发送到%s:%s Newsockfd:%d，claddr%d:\n”，clientAddr，buffer，Newsockfd，cl\u addr）；
}
}
关闭（newsockfd）；
}
}

客户c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <mqueue.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>



#define PORT 4444
#define BUF_SIZE 2000
#define MAX_SIZE    1024
#define MSG_STOP    "exit"

#define CHECK(x) \
        do { \
            if (!(x)) { \
                fprintf(stderr, "%s:%d: ", __func__, __LINE__); \
                perror(#x); \
                exit(-1); \
            } \
        } while (0) \

int createQUEUE_NAMEInSharedMemory(char * QUEUE_NAME ){
    char buffer[80], filename[200] = "/tmp/chat.txt";
    int fd, file_size, ret, size_written, size_read;
    void *addr;

    unlink( filename);
    fd = open( filename, O_CREAT|O_RDWR , 0777 );
    if( fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    size_written = write( fd, QUEUE_NAME, strlen(QUEUE_NAME) + 1 );
    if ( size_written == -1 ){
        perror("write");
        exit(0);
    }
    printf( "Wrote %d bytes into file %s\n", size_written, filename );

    lseek( fd, 0L, SEEK_SET );
    file_size = lseek( fd, 0L, SEEK_END );
    printf( "Size of file = %d bytes\n", file_size );

    /* Map the file into memory. */
    addr = mmap( 0, file_size, PROT_READ | PROT_WRITE , MAP_SHARED,
            fd, 0 );
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    /* Change the memory and synchronize it with the disk. */
    //                  memset( addr, 'B', 2 );
    //                  ret = msync( addr, file_size, MS_SYNC);
    //                  if( ret == -1) {
    //                      perror("msync");
    //                      exit(0);
    //                  }

    /* Close and reopen the file, and then read its contents. */
    close(fd);
    fd = open( filename, O_RDONLY);
    if( fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    size_read = read( fd, buffer, sizeof( buffer ) );
    printf( "File content = %s\n", buffer );

    close(fd);
    return EXIT_SUCCESS;
}



int main(){
    struct sockaddr_in addr, cl_addr;
    int sockfd, ret;
    char buffer[BUF_SIZE];
    struct hostent * server;
    char * serverAddr;
    char QUEUE_NAME[100];
    char * clientnumber;
    char temp[200];
    serverAddr = "127.0.0.1";
    printf("Server IP Address = %s\n",serverAddr);

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        printf("Error creating socket!\n");
        exit(1);
    }
    printf("Socket created...\n");

    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr(serverAddr);
    addr.sin_port = PORT;

    ret = connect(sockfd, (struct sockaddr *) &addr, sizeof(addr));
    if (ret < 0) {
        printf("Error connecting to the server!\n");
        exit(1);
    }
    printf("Connected to the server...\n");
    ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, NULL, NULL);
    if (ret < 0) {
        printf("Error receiving data!\n");
    } else {
        clientnumber = malloc(200 * sizeof(char));
        memcpy(clientnumber, buffer, strlen(buffer)+1);
        clientnumber = realloc(clientnumber, strlen(clientnumber));
        sprintf(QUEUE_NAME, "/%s", clientnumber);

        printf("Received USER ID: ");
        fputs(buffer, stdout);
        printf("\n");

    }

    ret = createQUEUE_NAMEInSharedMemory(QUEUE_NAME);
    if(ret < 0){
        printf("Error Creating QUERE_NAME : %s !\n",QUEUE_NAME);
    }else{
        printf("Sending QUERE_NAME (%s) to shared memory successful!\n",QUEUE_NAME);
        mqd_t mq;
        struct mq_attr attr;
        char buffer[MAX_SIZE + 1];
        int must_stop = 0;

        /* initialize the queue attributes */
        attr.mq_flags = 0;
        attr.mq_maxmsg = 10;
        attr.mq_msgsize = MAX_SIZE;
        attr.mq_curmsgs = 0;

        /* create the message queue */
        mq = mq_open(QUEUE_NAME, O_CREAT | O_RDWR, 0644, &attr);
        CHECK((mqd_t)-1 != mq);
        printf("Creating MSG QUERE_NAME : %s \n",QUEUE_NAME);
        do {
            ssize_t bytes_read;

            /* receive the message */
            bytes_read = mq_receive(mq, buffer, MAX_SIZE, NULL);
            CHECK(bytes_read >= 0);

            buffer[bytes_read] = '\0';
            if (! strncmp(buffer, MSG_STOP, strlen(MSG_STOP)))
            {
                must_stop = 1;
            }
            else
            {
                printf("Received: %s\n", buffer);
                 memcpy(temp, buffer, strlen(buffer)+1);
                sprintf(buffer, "%s:%s", clientnumber,temp);
                 mq_send(mq, buffer, MAX_SIZE, 0);
                ret = sendto(sockfd, buffer, BUF_SIZE, 0, (struct sockaddr *) &addr, sizeof(addr));
                if (ret < 0) {
                    printf("Error sending data!\n\t-%s", buffer);
                }

                ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, NULL, NULL);
                                if (ret < 0) {
                                    printf("Error receiving data!\n");
                                } else {
                                     mq_send(mq, buffer, MAX_SIZE, 0);
                                }


            }
        } while (!must_stop);
        printf("STOP MSG QUERE_NAME : %s \n",QUEUE_NAME);
        /* cleanup */
        CHECK((mqd_t)-1 != mq_close(mq));
        CHECK((mqd_t)-1 != mq_unlink(QUEUE_NAME));
    }



    //  memset(buffer, 0, BUF_SIZE);
    //  printf("%s: ",QUEUE_NAME);

    //  while (fgets(buffer, BUF_SIZE, stdin) != NULL) {
    //          ret = sendto(sockfd, buffer, BUF_SIZE, 0, (struct sockaddr *) &addr, sizeof(addr));
    //          if (ret < 0) {
    //              printf("Error sending data!\n\t-%s", buffer);
    //          }
    //          ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, NULL, NULL);
    //          if (ret < 0) {
    //              printf("Error receiving data!\n");
    //          } else {
    //              printf("Received: ");
    //              fputs(buffer, stdout);
    //              printf("\n");
    //              //printf("Enter your message(s): ");
    //              printf("%s: ",QUEUE_NAME);
    //          }
    //      }
    free(clientnumber);
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义端口4444
#定义BUF_尺寸2000
#定义最大大小1024
#定义消息停止“退出”
#定义检查（x）\
做{\
如果（！（x））{\
fprintf（标准，“%s:%d:”，\uuuuu函数，\uuuuu线）\
佩罗尔（#x）\
出口（-1）\
} \
}而（0）\
int createQUEUE_名称共享内存（字符*队列_名称）{
字符缓冲区[80]，文件名[200]=“/tmp/chat.txt”；
int fd、文件大小、ret、写入大小、读取大小；
无效*地址；
取消链接（文件名）；
fd=打开（文件名，O|u CREAT | O|u RDWR，0777）；
如果（fd==-1）{
佩罗（“公开”）；
退出（退出失败）；
}
写入的大小=写入（fd，队列名称，strlen（队列名称）+1）；
如果（写入的大小==-1）{
佩罗（“书面”）；
出口（0）；
}
printf（“将%d字节写入文件%s\n”，写入大小，文件名）；
lseek（fd，0L，寻道集）；
文件大小=lseek（fd，0L，寻道结束）；
printf（“文件大小=%d字节\n”，文件大小）；
/*将文件映射到内存中*/
addr=mmap（0，文件大小，保护读取，保护写入，映射共享，
fd，0）；
if（addr==MAP_失败）{
佩罗尔（“mmap”）；
退出（退出失败）；
}
/*更改内存并将其与磁盘同步*/
//memset（地址'B'，2）；
//ret=msync（地址、文件大小、同步）；
//如果（ret==-1）{
//perror（“msync”）；
//出口（0）；
//                  }
/*关闭并重新打开文件，然后读取其内容*/
关闭（fd）；
fd=打开（仅文件名）；
如果（fd==-1）{
佩罗（“公开”）；
退出（退出失败）；
}
size_read=read（fd，buffer，sizeof（buffer））；
printf（“文件内容=%s\n”，缓冲区）；
关闭（fd）；
返回退出成功；
}
int main（）{
地址中的结构sockaddr\u，cl\u addr；
int sockfd，ret；
字符缓冲区[BUF_大小]；
结构主机*服务器；
char*serverAddr；
字符队列名称[100]；
字符*客户号；
煤焦温度[200]；
serverAddr=“127.0.0.1”；
printf（“服务器IP地址=%s\n”，serverAddr）；
sockfd=套接字（AF_INET，SOCK_STREAM，0）；
if（sockfd<0）{
printf（“创建套接字时出错！\n”）；
出口（1）；
}
printf（“已创建套接字…\n”）；
memset（&addr，0，sizeof（addr））；
addr.sin_family=AF_INET；
addr.sin\u addr.s\u addr=inet\u addr（serverAddr）；
addr.sinu端口=端口；
ret=connect（sockfd，（结构sockaddr*）&addr，sizeof（addr））；
如果（ret<0）{
printf（“连接到服务器时出错！\n”）；
出口（1）；
}
printf（“已连接到服务器…\n”）；
ret=recvfrom（sockfd，buffer，BUF_SIZE，0，NULL，NULL）；
如果（ret<0）{
printf（“接收数据时出错！\n”）；
}否则{
clientnumber=malloc（2
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <mqueue.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

#define MAX_SIZE    1024
#define MSG_STOP    "exit"

#define CHECK(x) \
        do { \
            if (!(x)) { \
                fprintf(stderr, "%s:%d: ", __func__, __LINE__); \
                perror(#x); \
                exit(-1); \
            } \
        } while (0) \


char QUEUE_NAME[100];

void GetQUERENAME(){
    char buffer[80], filename[200] = "/tmp/chat.txt";
    int fd, file_size, ret, size_written, size_read;
    void *addr;

    fd = open( filename, O_RDONLY);
    if( fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    size_read = read( fd, buffer, sizeof( buffer ) );
    //printf( "File content = %s\n", buffer );
    memcpy(QUEUE_NAME, buffer, strlen(buffer)+1);
    //printf("QUEUE_NAME length = %d\n",strlen(QUEUE_NAME));
    close(fd);
}



int main(int argc, char *argv[]) {

    GetQUERENAME();
    mqd_t mq;
    char buffer[MAX_SIZE];

    /* open the mail queue */
    mq = mq_open(QUEUE_NAME, O_WRONLY);
    CHECK((mqd_t)-1 != mq);


    printf("Send to Client QUERE_NAME : %s (enter \"exit\" to stop it):\n",QUEUE_NAME);

    do {
        printf("> ");
        fflush(stdout);

        memset(buffer, 0, MAX_SIZE);
        fgets(buffer, MAX_SIZE, stdin);

        /* send the message */
        CHECK(0 <= mq_send(mq, buffer, MAX_SIZE, 0));

    } while (strncmp(buffer, MSG_STOP, strlen(MSG_STOP)));

    /* cleanup */
    CHECK((mqd_t)-1 != mq_close(mq));




    return EXIT_SUCCESS;
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <mqueue.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

#define MAX_SIZE    1024
#define MSG_STOP    "exit"

#define CHECK(x) \
        do { \
            if (!(x)) { \
                fprintf(stderr, "%s:%d: ", __func__, __LINE__); \
                perror(#x); \
                exit(-1); \
            } \
        } while (0) \


char QUEUE_NAME[100];

void GetQUERENAME(){
    char buffer[80], filename[200] = "/tmp/chat.txt";
    int fd, file_size, ret, size_written, size_read;
    void *addr;

    fd = open( filename, O_RDONLY);
    if( fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }
    size_read = read( fd, buffer, sizeof( buffer ) );
//  printf( "File content = %s\n", buffer );
    memcpy(QUEUE_NAME, buffer, strlen(buffer)+1);
//  printf("QUEUE_NAME length = %d\n",strlen(QUEUE_NAME));
    close(fd);
}



int main(int argc, char **argv)
{
    GetQUERENAME();
    mqd_t mq;
    struct mq_attr attr;
    char buffer[MAX_SIZE + 1];
    int must_stop = 0;

    /* initialize the queue attributes */
    attr.mq_flags = 0;
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = MAX_SIZE;
    attr.mq_curmsgs = 0;

    /* create the message queue */
    mq = mq_open(QUEUE_NAME, O_CREAT | O_RDONLY, 0644, &attr);
    CHECK((mqd_t)-1 != mq);

    do {
        ssize_t bytes_read;

        /* receive the message */
        bytes_read = mq_receive(mq, buffer, MAX_SIZE, NULL);
        CHECK(bytes_read >= 0);

        buffer[bytes_read] = '\0';
        if (! strncmp(buffer, MSG_STOP, strlen(MSG_STOP)))
        {
            must_stop = 1;
        }
        else
        {
            printf("%s\n", buffer);
        }
    } while (!must_stop);

    /* cleanup */
    CHECK((mqd_t)-1 != mq_close(mq));
    CHECK((mqd_t)-1 != mq_unlink(QUEUE_NAME));

    return 0;
}

while(1)
  {
  FD_ZERO(&readfds);
  FD_SET(sockfd,&readfds);
  for(each client FD)
    {
    FD_SET(clientfd,&readfds);
    }
  select(maxfds,&readfds,NULL,NULL,NULL);
  if(FD_ISSET(sockfd,&readfds))
    {
    /* accept() a new client */;
    }
  for(each client FD)
    {
    if(FD_ISSET(clientfd,&readfds))
      {
      /* read input */
      }
    }
  }