linux 命名管道的问题,急求帮忙!!谢谢了
代码如下：
fifo_read.c
fifo_write.c也是一样的问题，运行就返回打开文件错误，返回-1 展开
/* fifo_seqnum_client.c
A simple client that uses a well-known FIFO to request a (trivial)
"sequence number service". This client creates its own FIFO (using a
convention agreed upon by client and server) which is used to receive a reply
from the server. The client then sends a request to the server consisting of
its PID and the length of the sequence it wishes to be allocated. The client
then reads the server's response and displays it on stdout.
See fifo_seqnum.h for the format of request and response messages.
The server is in fifo_seqnum_server.c.
*/
#include "fifo_seqnum.h"
static char clientFifo[CLIENT_FIFO_NAME_LEN];
static void /* Invoked on exit to delete client FIFO */
removeFifo(void)
{
unlink(clientFifo);
}
int
main(int argc, char *argv[])
{
int serverFd, clientFd;
struct request req;
struct response resp;
if (argc > 1 && strcmp(argv[1], "--help") == 0)
usageErr("%s [seq-len...]\n", argv[0]);
/* Create our FIFO (before sending request, to avoid a race) */
umask(0); /* So we get the permissions we want */
snprintf(clientFifo, CLIENT_FIFO_NAME_LEN, CLIENT_FIFO_TEMPLATE,
(long) getpid());
if (mkfifo(clientFifo, S_IRUSR | S_IWUSR | S_IWGRP) == -1
&& errno != EEXIST)
errExit("mkfifo %s", clientFifo);
if (atexit(removeFifo) != 0)
errExit("atexit");
/* Construct request message, open server FIFO, and send message */
req.pid = getpid();
req.seqLen = (argc > 1) ? getInt(argv[1], GN_GT_0, "seq-len") : 1;
serverFd = open(SERVER_FIFO, O_WRONLY);
if (serverFd == -1)
errExit("open %s", SERVER_FIFO);
if (write(serverFd, &req, sizeof(struct request)) !=
sizeof(struct request))
fatal("Can't write to server");
/* Open our FIFO, read and display response */
clientFd = open(clientFifo, O_RDONLY);
if (clientFd == -1)
errExit("open %s", clientFifo);
if (read(clientFd, &resp, sizeof(struct response))
!= sizeof(struct response))
fatal("Can't read response from server");
printf("%d\n", resp.seqNum);
exit(EXIT_SUCCESS);
}
/* fifo_seqnum_server.c
An example of a server using a FIFO to handle client requests.
The "service" provided is the allocation of unique sequential
numbers. Each client submits a request consisting of its PID, and
the length of the sequence it is to be allocated by the server.
The PID is used by both the server and the client to construct
the name of the FIFO used by the client for receiving responses.
The server reads each client request, and uses the client's FIFO
to send back the starting value of the sequence allocated to that
client. The server then increments its counter of used numbers
by the length specified in the client request.
See fifo_seqnum.h for the format of request and response messages.
The client is in fifo_seqnum_client.c.
*/
#include <signal.h>
#include "fifo_seqnum.h"
int
main(int argc, char *argv[])
{
int serverFd, dummyFd, clientFd;
char clientFifo[CLIENT_FIFO_NAME_LEN];
struct request req;
struct response resp;
int seqNum = 0; /* This is our "service" */
/* Create well-known FIFO, and open it for reading */
umask(0); /* So we get the permissions we want */
if (mkfifo(SERVER_FIFO, S_IRUSR | S_IWUSR | S_IWGRP) == -1
&& errno != EEXIST)
errExit("mkfifo %s", SERVER_FIFO);
serverFd = open(SERVER_FIFO, O_RDONLY);
if (serverFd == -1)
errExit("open %s", SERVER_FIFO);
/* Open an extra write descriptor, so that we never see EOF */
dummyFd = open(SERVER_FIFO, O_WRONLY);
if (dummyFd == -1)
errExit("open %s", SERVER_FIFO);
/* Let's find out about broken client pipe via failed write() */
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
errExit("signal");
for (;;) { /* Read requests and send responses */
if (read(serverFd, &req, sizeof(struct request))
!= sizeof(struct request)) {
fprintf(stderr, "Error reading request; discarding\n");
continue; /* Either partial read or error */
}
/* Open client FIFO (previously created by client) */
snprintf(clientFifo, CLIENT_FIFO_NAME_LEN, CLIENT_FIFO_TEMPLATE,
(long) req.pid);
clientFd = open(clientFifo, O_WRONLY);
if (clientFd == -1) { /* Open failed, give up on client */
errMsg("open %s", clientFifo);
continue;
}
/* Send response and close FIFO */
resp.seqNum = seqNum;
if (write(clientFd, &resp, sizeof(struct response))
!= sizeof(struct response))
fprintf(stderr, "Error writing to FIFO %s\n", clientFifo);
if (close(clientFd) == -1)
errMsg("close");
seqNum += req.seqLen; /* Update our sequence number */
}
}
这个我测试过没问题
mkfifo（fifo_name, S_IRUSR | S_IWUSR）;
谢谢你的回答，我百度mkfifo是那样写的啊，而且即使我按照你的方式写，也是一样的错误，不知道为什么。
