mmsg.test: check memory access by sendmmsg and recvmmsg decoders

* tests/tests.h (tail_memdup): New prototype.
* tests/tail_alloc.c (tail_memdup): New function.
* tests/mmsg.c (main): Place all objects passed to sendmmsg and recvmmsg
at the end of memory pages followed by inaccessible pages.

diff --git a/tests/mmsg.c b/tests/mmsg.c
index 4dae02862fe3c125775e9714fbc1c6169dace0a1..630ad1ddc34491fdfe6ff4f53cbbc3fa671cca39 100644 (file)
--- a/tests/mmsg.c
+++ b/tests/mmsg.c
@@ -33,7 +33,6 @@
 
 # include <assert.h>
 # include <errno.h>
-# include <fcntl.h>
 # include <unistd.h>
 # include <sys/socket.h>
 
@@ -81,64 +80,59 @@ int
 main(void)
 {
        const int R = 0, W = 1;
-       int fd;
        int sv[2];
-       char one[] = "one";
-       char two[] = "two";
-       char three[] = "three";
+
+       (void) close(0);
+       (void) close(1);
+       if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv))
+               perror_msg_and_skip("socketpair");
+       assert(R == sv[0]);
+       assert(W == sv[1]);
+
+       static const char const one[] = "one";
+       static const char const two[] = "two";
+       static const char const three[] = "three";
+       void *copy_one = tail_memdup(one, sizeof(one) - 1);
+       void *copy_two = tail_memdup(two, sizeof(two) - 1);
+       void *copy_three = tail_memdup(three, sizeof(three) - 1);
 
        struct iovec iov[] = {
                {
-                       .iov_base = one,
+                       .iov_base = copy_one,
                        .iov_len = sizeof(one) - 1
                }, {
-                       .iov_base = two,
+                       .iov_base = copy_two,
                        .iov_len = sizeof(two) - 1
                }, {
-                       .iov_base = three,
+                       .iov_base = copy_three,
                        .iov_len = sizeof(three) - 1
                }
        };
+       struct iovec *copy_iov = tail_memdup(iov, sizeof(iov));
 
        struct mmsghdr mmh[] = {
                {
                        .msg_hdr = {
-                               .msg_iov = iov + 0,
+                               .msg_iov = copy_iov + 0,
                                .msg_iovlen = 2,
                        }
                }, {
                        .msg_hdr = {
-                               .msg_iov = iov + 2,
+                               .msg_iov = copy_iov + 2,
                                .msg_iovlen = 1,
                        }
                }
        };
+       void *copy_mmh = tail_memdup(mmh, sizeof(mmh));
 # define n_mmh (sizeof(mmh)/sizeof(mmh[0]))
 
-       /*
-        * Following open/dup2/close calls make the output of strace
-        * more predictable, so we can just compare the output and
-        * expected output (mmsg.expected) for testing purposes.
-        */
-       while ((fd = open("/dev/null", O_RDWR)) < 3)
-               assert(fd >= 0);
-       (void) close(3);
-
-       if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv))
-               perror_msg_and_skip("socketpair");
-
-       assert(dup2(sv[W], W) == W);
-       assert(close(sv[W]) == 0);
-       assert(dup2(sv[R], R) == R);
-       assert(close(sv[R]) == 0);
-
-       int r = send_mmsg(W, mmh, n_mmh, MSG_DONTROUTE | MSG_NOSIGNAL);
+       int r = send_mmsg(W, copy_mmh, n_mmh, MSG_DONTROUTE | MSG_NOSIGNAL);
        if (r < 0 && errno == ENOSYS)
                perror_msg_and_skip("sendmmsg");
        assert((size_t)r == n_mmh);
        assert(close(W) == 0);
 
-       assert(recv_mmsg(R, mmh, n_mmh, MSG_DONTWAIT, NULL) == n_mmh);
+       assert(recv_mmsg(R, copy_mmh, n_mmh, MSG_DONTWAIT, NULL) == n_mmh);
        assert(close(R) == 0);
 
        return 0;

diff --git a/tests/tail_alloc.c b/tests/tail_alloc.c
index 2b8b14ed4f0b003cb4c8d1ae90de4391986b96ef..82e1aacb1fd10844ab9f03756be8b65fe17358d3 100644 (file)
--- a/tests/tail_alloc.c
+++ b/tests/tail_alloc.c
@@ -50,3 +50,11 @@ tail_alloc(const size_t size)
        memset(start_work, 0xff, len);
        return tail_guard - size;
 }
+
+void *
+tail_memdup(const void *p, const size_t size)
+{
+       void *dest = tail_alloc(size);
+       memcpy(dest, p, size);
+       return dest;
+}

diff --git a/tests/tests.h b/tests/tests.h
index 91fa24ef364db988e4a68b28c7f097250285755c..36ddea3169c5bf9227c7cef4ff52b24dae7354fb 100644 (file)
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -55,6 +55,9 @@ void perror_msg_and_skip(const char *, ...)
  */
 void *tail_alloc(const size_t)
        ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE((1));
+/* Allocate memory using tail_alloc, then memcpy. */
+void *tail_memdup(const void *, const size_t)
+       ATTRIBUTE_MALLOC ATTRIBUTE_ALLOC_SIZE((2));
 
 # define SKIP_MAIN_UNDEFINED(arg) \
        int main(void) { error_msg_and_skip("undefined: %s", arg); }