特集12 IPCのメッセージキュー

#include <sys/types.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <stddef.h>     /* For definition of offsetof() */
#include <limits.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/wait.h>
#include <string.h>
#include <errno.h>

#define SERVER_KEY 0x1aaaaaa1     /* Key for server's message queue */

struct requestMsg {                /* Requests (client to server) */
	long mtype;                   /* unused */
	int clientId;                 /* ID of client's message queue */
	char pathname[PATH_MAX];      /* File to be returned */
}; 

#define REQ_MSG_SIZE (offsetof(struct requestMsg, pathname) - \
					offsetof(struct requestMsg, clientId) + PATH_MAX)

#define RESP_MSG_SIZE 8192

struct responseMsg {
	long mtype;
	char data[RESP_MSG_SIZE];
};

/* Types for response messages sent from server to client */
#define RESP_MT_FAILURE 1       /* File couldn't be opened */
#define RESP_MT_DATA    2      /* Message contains file data */
#define RESP_MT_END     3     /* File data complete */

#include "svmsg_file.h"

static void               /* SIGCHLD handler */
grimReaper(int sig)
{
	int savedErrno;
	savedErrno = errno;  /* waitpid() might change 'errno' */
	while (waitpid(-1, NULL, WNOHANG) > 0)
		continue;
	errno = savedErrno;
}

static void
serveRequest(const struct requestMsg *req)  /* Executed in child process: serve a single client */
{
	int fd;
	ssize_t numRead;
	struct responseMsg resp;
	
	fd = open(req->pathname, O_RDONLY);
	if (fd == -1) {                          /* Open failed: send error text */
		resp.mtype = RESP_MT_FAILURE;
		snprintf(resp.data, sizeof(resp.data), "%s", "Couldn't open");
		msgsnd(req->clientId, &resp, strlen(resp.data) + 1, 0);
		exit(EXIT_FAILURE);
	}
	
	resp.mtype = RESP_MT_DATA;
	while ((numRead = read(fd, resp.data, RESP_MSG_SIZE)) > 0)
		if (msgsnd(req->clientId, &resp, numRead, 0) == -1)
			break;
	/* Send a message of type RESP_MT_END to signify end-of-file */
	resp.mtype = RESP_MT_END;
	msgsnd(req->clientId, &resp, 0, 0);    /* Zero-length mtext */
}

int
main(int argc, char *argv[])
{
	struct requestMsg req;
	pid_t pid;
	ssize_t msgLen;
	int serverId;
	struct sigaction sa;
	
	/* Create server message queue */
	serverId = msgget(SERVER_KEY, IPC_CREAT | IPC_EXCL |
						S_IRUSR | S_IWUSR | S_IWGRP);
	if (serverId == -1)
		perror("msgget");
	
	/* Establish SIGCHLD handler to reap terminated children */
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = SA_RESTART;
	sa.sa_handler = grimReaper;
	if (sigaction(SIGCHLD, &sa, NULL) == -1)
		perror("sigaction error!");
	/* Read requests, handle each in a separate child process */
	for (;;) {
		msgLen = msgrcv(serverId, &req, REQ_MSG_SIZE, 0, 0);
		if (msgLen == -1) {
			if (errno == EINTR)
				continue;
			perror("msgrcv error");
			break;
		}
		
		pid = fork(); 
		if (pid == -1) { 
			perror("fork"); 
			break; 
		} 

		if (pid == 0) { 
			serveRequest(&req); 
			_exit(EXIT_SUCCESS); 
		} 
		
	}
	
	/* If msgrcv() or fork() fails, remove server MQ and exit */
	if (msgctl(serverId, IPC_RMID, NULL) == -1)
		perror("msgctl");
	exit(EXIT_SUCCESS);

}

#include "svmsg_file.h"

static int clientId;

static void
removeQueue(void)
{
	if (msgctl(clientId, IPC_RMID, NULL) == -1)
		perror("msgctl");

}

int
main(int argc, char *argv[])
{
	struct requestMsg req;
	struct responseMsg resp;
	int serverId, numMsgs;
	ssize_t msgLen, totBytes;
	
	if (argc != 2 || strcmp(argv[1], "--help") == 0)
		perror("%s pathname
", argv[0]);
		
	if (strlen(argv[1]) > sizeof(req.pathname) - 1)
		perror("pathname too long (max: %ld bytes)
",
						(long) sizeof(req.pathname) - 1);
	/* Get server's queue identifier; create queue for response */
	serverId = msgget(SERVER_KEY, S_IWUSR);
	if (serverId == -1)
		perror("msgget - server message queue");
	
	clientId = msgget(IPC_PRIVATE, S_IRUSR | S_IWUSR | S_IWGRP);
	if (clientId == -1)
		perror("msgget - client message queue");
		
	if (atexit(removeQueue) != 0)
		perror("atexit");
		
	/* Send message asking for file named in argv[1] */
	req.mtype = 1;    /* Any type will do */
	req.clientId = clientId;
	strncpy(req.pathname, argv[1], sizeof(req.pathname) - 1);
	req.pathname[sizeof(req.pathname) - 1] = '\0';
	
	if (msgsnd(serverId, &req, REQ_MSG_SIZE, 0) == -1)
		perror("msgsnd");
		
	/* Get first response, which may be failure notification */
	msgLen = msgrcv(clientId, &resp, RESP_MSG_SIZE, 0, 0);
	if (msgLen == -1)
		perror("msgrcv");

	if (resp.mtype == RESP_MT_FAILURE) {
		printf("%s
", resp.data);
		if (msgctl(clientId, IPC_RMID, NULL) == -1)
			perror("msgctl");
		exit(EXIT_FAILURE);
	}
	
	totBytes = msgLen;
	for (numMsgs = 1; resp.mtype == RESP_MT_DATA; numMsgs++) {
		msgLen = msgrcv(clientId, &resp, RESP_MSG_SIZE, 0, 0);
		if (msgLen == -1)
			perror("msgrcv");
		totBytes += msgLen;
	}
	
	printf("Received %ld bytes (%d messages)
", (long) totBytes, numMsgs);
	
	exit(EXIT_SUCCESS);

}