301 lines
7.5 KiB
C
301 lines
7.5 KiB
C
|
#include <sys/types.h>
|
||
|
#include <sys/wait.h>
|
||
|
#include <sys/syslimits.h>
|
||
|
#include <errno.h>
|
||
|
#include <fcntl.h>
|
||
|
#include <signal.h>
|
||
|
#include <stdio.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <unistd.h>
|
||
|
|
||
|
int max_error = 5;
|
||
|
#include "common.h"
|
||
|
|
||
|
|
||
|
void copy_subtests(void);
|
||
|
void test_pipe_cloexec(void);
|
||
|
void test_pipe_flag_setting(void);
|
||
|
void test_pipe_nonblock(void);
|
||
|
void test_pipe_normal(void);
|
||
|
void test_pipe_nosigpipe(void);
|
||
|
void alarm_handler(int sig);
|
||
|
void pipe_handler(int sig);
|
||
|
|
||
|
static int seen_pipe_signal = 0;
|
||
|
static int seen_alarm_signal = 0;
|
||
|
|
||
|
void
|
||
|
alarm_handler(int sig)
|
||
|
{
|
||
|
if (seen_pipe_signal == 0)
|
||
|
seen_pipe_signal = -1;
|
||
|
seen_alarm_signal = 1;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
pipe_handler(int sig)
|
||
|
{
|
||
|
seen_pipe_signal = 1;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
copy_subtests()
|
||
|
{
|
||
|
char *subtests[] = { "t68a", "t68b" };
|
||
|
char copy_cmd[8 + PATH_MAX + 1];
|
||
|
int i, no_tests;
|
||
|
|
||
|
no_tests = sizeof(subtests) / sizeof(char *);
|
||
|
|
||
|
for (i = 0; i < no_tests; i++) {
|
||
|
snprintf(copy_cmd, 8 + PATH_MAX, "cp ../%s .", subtests[i]);
|
||
|
system(copy_cmd);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void
|
||
|
test_pipe_normal()
|
||
|
{
|
||
|
/* Verify pipe2 creates pipes that behave like a normal pipe */
|
||
|
|
||
|
int pipes[2];
|
||
|
char buf_in[1], buf_out[1];
|
||
|
pid_t pid;
|
||
|
|
||
|
subtest = 2;
|
||
|
|
||
|
if (pipe2(pipes, 0) != 0) e(1);
|
||
|
|
||
|
buf_out[0] = 'T';
|
||
|
if (write(pipes[1], buf_out, sizeof(buf_out)) != sizeof(buf_out)) e(2);
|
||
|
if (read(pipes[0], buf_in, sizeof(buf_in)) != sizeof(buf_in)) e(3);
|
||
|
if (buf_out[0] != buf_in[0]) e(4);
|
||
|
|
||
|
/* When we close the write end, reading should fail */
|
||
|
if (close(pipes[1]) != 0) e(5);
|
||
|
if (read(pipes[0], buf_in, sizeof(buf_in)) != 0) e(6);
|
||
|
|
||
|
/* Let's retry that experiment the other way around. Install a signal
|
||
|
* handler to catch SIGPIPE. Install an alarm handler to make sure
|
||
|
* this test finishes in finite time. */
|
||
|
if (pipe2(pipes, 0) != 0) e(7);
|
||
|
signal(SIGPIPE, pipe_handler);
|
||
|
signal(SIGALRM, alarm_handler);
|
||
|
seen_pipe_signal = 0;
|
||
|
seen_alarm_signal = 0;
|
||
|
alarm(1);
|
||
|
if (close(pipes[0]) != 0) e(8);
|
||
|
if (write(pipes[1], buf_out, sizeof(buf_out)) != -1) e(9);
|
||
|
while (seen_pipe_signal == 0)
|
||
|
;
|
||
|
if (seen_pipe_signal != 1) e(10);
|
||
|
if (close(pipes[1]) != 0) e(11);
|
||
|
|
||
|
/* Collect alarm signal */
|
||
|
while (seen_alarm_signal == 0)
|
||
|
;
|
||
|
|
||
|
if (pipe2(pipes, 0) != 0) e(12);
|
||
|
|
||
|
/* Now fork and verify we can write to the pipe */
|
||
|
pid = fork();
|
||
|
if (pid < 0) e(13);
|
||
|
if (pid == 0) {
|
||
|
/* We're the child */
|
||
|
char fd_buf[2];
|
||
|
|
||
|
/* Verify we can still write a byte into the pipe */
|
||
|
if (write(pipes[1], buf_out, sizeof(buf_out)) != 1) e(14);
|
||
|
|
||
|
snprintf(fd_buf, sizeof(fd_buf), "%d", pipes[1]);
|
||
|
execl("./t68a", "t68a", fd_buf, NULL);
|
||
|
|
||
|
exit(1); /* Should not be reached */
|
||
|
} else {
|
||
|
/* We're the parent */
|
||
|
int result;
|
||
|
|
||
|
if (waitpid(pid, &result, 0) == -1) e(15);
|
||
|
if (WEXITSTATUS(result) != 0) e(16);
|
||
|
}
|
||
|
|
||
|
if (close(pipes[0]) != 0) e(17);
|
||
|
if (close(pipes[1]) != 0) e(18);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
test_pipe_cloexec()
|
||
|
{
|
||
|
/* Open a pipe with O_CLOEXEC */
|
||
|
int flags;
|
||
|
int pipes[2];
|
||
|
pid_t pid;
|
||
|
char buf_in[1], buf_out[1];
|
||
|
|
||
|
subtest = 3;
|
||
|
|
||
|
if (pipe2(pipes, O_CLOEXEC) != 0) e(1);
|
||
|
|
||
|
/* Verify O_CLOEXEC flag is set */
|
||
|
flags = fcntl(pipes[0], F_GETFD);
|
||
|
if (flags < 0) e(2);
|
||
|
if (!(flags & FD_CLOEXEC)) e(3);
|
||
|
|
||
|
pid = fork();
|
||
|
if (pid < 0) e(4);
|
||
|
if (pid == 0) {
|
||
|
/* We're the child */
|
||
|
char fd_buf[2];
|
||
|
|
||
|
/* Verify we can still write a byte into the pipe */
|
||
|
buf_in[0] = 0;
|
||
|
buf_out[0] = 'T';
|
||
|
if (write(pipes[1], buf_out, sizeof(buf_out)) != 1) e(5);
|
||
|
if (read(pipes[0], buf_in, sizeof(buf_in)) != 1) e(6);
|
||
|
if (buf_out[0] != buf_in[0]) e(7);
|
||
|
|
||
|
/* Verify FD_CLOEXEC flag is still set */
|
||
|
flags = fcntl(pipes[0], F_GETFD);
|
||
|
if (flags < 0) e(8);
|
||
|
if (!(flags & FD_CLOEXEC)) e(9);
|
||
|
|
||
|
snprintf(fd_buf, sizeof(fd_buf), "%d", pipes[0]);
|
||
|
execl("./t68b", "t68b", fd_buf, NULL);
|
||
|
|
||
|
exit(1); /* Should not be reached */
|
||
|
} else {
|
||
|
/* We're the parent */
|
||
|
int result;
|
||
|
|
||
|
if (waitpid(pid, &result, 0) == -1) e(10);
|
||
|
if (WEXITSTATUS(result) != 0) e(11);
|
||
|
}
|
||
|
|
||
|
/* Eventhough our child's pipe should've been closed upon exec, our
|
||
|
* pipe should still be functioning.
|
||
|
*/
|
||
|
buf_in[0] = 0;
|
||
|
buf_out[0] = 't';
|
||
|
if (write(pipes[1], buf_out, sizeof(buf_out)) != sizeof(buf_out)) e(12);
|
||
|
if (read(pipes[0], buf_in, sizeof(buf_in)) != sizeof(buf_in)) e(13);
|
||
|
if (buf_out[0] != buf_in[0]) e(14);
|
||
|
|
||
|
if (close(pipes[0]) != 0) e(15);
|
||
|
if (close(pipes[1]) != 0) e(16);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
test_pipe_nonblock()
|
||
|
{
|
||
|
/* Open a pipe with O_NONBLOCK */
|
||
|
char *buf_in, *buf_out;
|
||
|
int pipes[2];
|
||
|
size_t pipe_size;
|
||
|
|
||
|
subtest = 4;
|
||
|
|
||
|
if (pipe2(pipes, O_NONBLOCK) != 0) e(1);
|
||
|
if ((pipe_size = fpathconf(pipes[0], _PC_PIPE_BUF)) == -1) e(2);
|
||
|
buf_in = calloc(2, pipe_size); /* Allocate twice the buffer size */
|
||
|
if (buf_in == NULL) e(3);
|
||
|
buf_out = calloc(2, pipe_size); /* Idem dito for output buffer */
|
||
|
if (buf_out == NULL) e(4);
|
||
|
|
||
|
/* According to POSIX, a pipe with O_NONBLOCK set shall never block.
|
||
|
* When we attempt to write PIPE_BUF or less bytes, and there is
|
||
|
* sufficient space available, write returns nbytes. Else write will
|
||
|
* return -1 and not transfer any data.
|
||
|
*/
|
||
|
if (write(pipes[1], buf_out, 1) != 1) e(5); /* Write 1 byte */
|
||
|
if (write(pipes[1], buf_out, pipe_size) != -1) e(6); /* Can't fit */
|
||
|
if (errno != EAGAIN) e(7);
|
||
|
|
||
|
/* When writing more than PIPE_BUF bytes and when at least 1 byte can
|
||
|
* be tranferred, return the number of bytes written. We've written 1
|
||
|
* byte, so there are PIPE_BUF - 1 bytes left. */
|
||
|
if (write(pipes[1], buf_out, pipe_size + 1) != pipe_size - 1) e(8);
|
||
|
|
||
|
/* Read out all data and try again. This time we should be able to
|
||
|
* write PIPE_BUF bytes. */
|
||
|
if (read(pipes[0], buf_in, pipe_size) != pipe_size) e(9);
|
||
|
if (read(pipes[0], buf_in, 1) != -1) e(10); /* Empty, can't read */
|
||
|
if (errno != EAGAIN) e(11);
|
||
|
if (write(pipes[1], buf_out, pipe_size + 1) != pipe_size) e(12);
|
||
|
if (close(pipes[0]) != 0) e(13);
|
||
|
if (close(pipes[1]) != 0) e(14);
|
||
|
free(buf_in);
|
||
|
free(buf_out);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
test_pipe_nosigpipe(void)
|
||
|
{
|
||
|
/* Let's retry the writing to pipe without readers experiment. This time we set
|
||
|
* the O_NOSIGPIPE flag to prevent getting a signal. */
|
||
|
int pipes[2];
|
||
|
char buf_out[1];
|
||
|
|
||
|
subtest = 5;
|
||
|
|
||
|
if (pipe2(pipes, O_NOSIGPIPE) != 0) e(7);
|
||
|
signal(SIGPIPE, pipe_handler);
|
||
|
signal(SIGALRM, alarm_handler);
|
||
|
seen_pipe_signal = 0;
|
||
|
seen_alarm_signal = 0;
|
||
|
alarm(1);
|
||
|
if (close(pipes[0]) != 0) e(8);
|
||
|
if (write(pipes[1], buf_out, sizeof(buf_out)) != -1) e(9);
|
||
|
|
||
|
/* Collect alarm signal */
|
||
|
while (seen_alarm_signal == 0)
|
||
|
;
|
||
|
if (errno != EPIPE) e(10);
|
||
|
if (seen_pipe_signal != -1) e(11); /* Alarm sig handler set it to -1 */
|
||
|
if (close(pipes[1]) != 0) e(12);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
test_pipe_flag_setting()
|
||
|
{
|
||
|
int pipes[2];
|
||
|
|
||
|
subtest = 1;
|
||
|
|
||
|
/* Create standard pipe with no flags and verify they're off */
|
||
|
if (pipe2(pipes, 0) != 0) e(1);
|
||
|
if (fcntl(pipes[0], F_GETFD) != 0) e(2);
|
||
|
if (fcntl(pipes[1], F_GETFD) != 0) e(3);
|
||
|
if (fcntl(pipes[0], F_GETFL) & O_NONBLOCK) e(4);
|
||
|
if (fcntl(pipes[1], F_GETFL) & O_NONBLOCK) e(5);
|
||
|
if (fcntl(pipes[0], F_GETNOSIGPIPE) != -1) e(6);
|
||
|
if (fcntl(pipes[1], F_GETNOSIGPIPE) != -1) e(7);
|
||
|
if (close(pipes[0]) != 0) e(8);
|
||
|
if (close(pipes[1]) != 0) e(9);
|
||
|
|
||
|
/* Create pipe with all flags and verify they're on */
|
||
|
if (pipe2(pipes, O_CLOEXEC|O_NONBLOCK|O_NOSIGPIPE) != 0) e(10);
|
||
|
if (fcntl(pipes[0], F_GETFD) != FD_CLOEXEC) e(11);
|
||
|
if (fcntl(pipes[1], F_GETFD) != FD_CLOEXEC) e(12);
|
||
|
if (!(fcntl(pipes[0], F_GETFL) & O_NONBLOCK)) e(13);
|
||
|
if (!(fcntl(pipes[1], F_GETFL) & O_NONBLOCK)) e(14);
|
||
|
if (fcntl(pipes[0], F_GETNOSIGPIPE) == -1) e(15);
|
||
|
if (fcntl(pipes[1], F_GETNOSIGPIPE) == -1) e(16);
|
||
|
if (close(pipes[0]) != 0) e(17);
|
||
|
if (close(pipes[1]) != 0) e(18);
|
||
|
}
|
||
|
|
||
|
int
|
||
|
main(int argc, char *argv[])
|
||
|
{
|
||
|
start(68);
|
||
|
copy_subtests();
|
||
|
test_pipe_flag_setting();
|
||
|
test_pipe_normal();
|
||
|
test_pipe_cloexec();
|
||
|
test_pipe_nonblock();
|
||
|
test_pipe_nosigpipe();
|
||
|
quit();
|
||
|
return(-1); /* Unreachable */
|
||
|
}
|
||
|
|