git.ozlabs.org Git - ccan/blob - ccan/net/test/run-bind.c

   1 #include <ccan/net/net.h>
   2 #include <ccan/tap/tap.h>
   3 #include <sys/time.h>
   4 #include <unistd.h>
   5 #include <sys/types.h>
   6 #include <sys/wait.h>
   7 #include <stdio.h>
   8 #include <err.h>
   9 #include <sys/types.h>
  10 #include <sys/socket.h>
  11 #include <netinet/in.h>
  12
  13 static int ipv6_only;
  14
  15 #ifdef IPV6_V6ONLY
  16 static int my_setsockopt(int sockfd, int level, int optname,
  17                          const void *optval, socklen_t optlen)
  18 {
  19         int ret;
  20         setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &ipv6_only,
  21                    sizeof(ipv6_only));
  22         ret = setsockopt(sockfd, level, optname, optval, optlen);
  23         return ret;
  24 }
  25 #define setsockopt my_setsockopt
  26 #endif
  27
  28 #include <ccan/net/net.c>
  29
  30 #define TEST_PORT "65001"
  31
  32 static void do_connect(int family, int type)
  33 {
  34         int fd, ret;
  35         struct addrinfo *addr;
  36         char buf[8];
  37
  38         /* Just in case... */
  39         alarm(5);
  40         addr = net_client_lookup(NULL, TEST_PORT, family, type);
  41         fd = net_connect(addr);
  42         if (fd < 0)
  43                 err(1, "Failed net_connect");
  44         freeaddrinfo(addr);
  45
  46         ret = write(fd, "Yay!", strlen("Yay!"));
  47         if (ret != strlen("Yay!"))
  48                 err(1, "Write returned %i", ret);
  49         ret = read(fd, buf, sizeof(buf));
  50         if (ret != 5)
  51                 err(1, "Read returned %i", ret);
  52         if (memcmp(buf, "metoo", ret) != 0)
  53                 err(1, "Read returned '%.*s'", ret, buf);
  54         close(fd);
  55 }
  56
  57 static int wait_for_readable(int fds[2], int num_fds)
  58 {
  59         int i, max_fd = -1;
  60         fd_set set;
  61
  62         FD_ZERO(&set);
  63         for (i = 0; i < num_fds; i++) {
  64                 if (fds[i] > max_fd)
  65                         max_fd = fds[i];
  66                 FD_SET(fds[i], &set);
  67         }
  68
  69         select(max_fd+1, &set, NULL, NULL, NULL);
  70         for (i = 0; i < num_fds; i++) {
  71                 if (FD_ISSET(fds[i], &set))
  72                         return i;
  73         }
  74         return num_fds+1;
  75 }
  76
  77 int main(void)
  78 {
  79         struct addrinfo *addr;
  80         int fds[2], num_fds, i, fd, status, ret;
  81         char buf[20];
  82         union {
  83                 struct sockaddr addr;
  84                 struct sockaddr_in ipv4;
  85                 struct sockaddr_in6 ipv6;
  86         } remote_addr;
  87         socklen_t addlen = sizeof(remote_addr);
  88
  89         plan_tests(35);
  90
  91         /* Simple TCP test. */
  92         addr = net_server_lookup(TEST_PORT, AF_UNSPEC, SOCK_STREAM);
  93         ok1(addr);
  94         num_fds = net_bind(addr, fds);
  95         ok1(num_fds == 1 || num_fds == 2);
  96
  97         if (!fork()) {
  98                 for (i = 0; i < num_fds; i++)
  99                         close(fds[i]);
 100                 do_connect(AF_UNSPEC, SOCK_STREAM);
 101                 exit(0);
 102         }
 103
 104         i = wait_for_readable(fds, num_fds);
 105         ok1(i < num_fds);
 106         fd = accept(fds[i], NULL, NULL);
 107         ok1(fd >= 0);
 108
 109         ret = read(fd, buf, strlen("Yay!"));
 110         ok1(ret == strlen("Yay!"));
 111         ok1(memcmp(buf, "Yay!", ret) == 0);
 112         ret = write(fd, "metoo", strlen("metoo"));
 113         ok1(ret == strlen("metoo"));
 114         ok1(wait(&status) != -1);
 115         ok1(WIFEXITED(status));
 116         ok1(WEXITSTATUS(status) == 0);
 117         close(fd);
 118         for (i = 0; i < num_fds; i++)
 119                 close(fds[i]);
 120
 121         /* Simple UDP test. */
 122         addr = net_server_lookup(TEST_PORT, AF_UNSPEC, SOCK_DGRAM);
 123         ok1(addr);
 124         num_fds = net_bind(addr, fds);
 125         ok1(num_fds == 1 || num_fds == 2);
 126
 127         if (!fork()) {
 128                 for (i = 0; i < num_fds; i++)
 129                         close(fds[i]);
 130                 do_connect(AF_UNSPEC, SOCK_DGRAM);
 131                 exit(0);
 132         }
 133
 134         i = wait_for_readable(fds, num_fds);
 135         ok1(i < num_fds);
 136         fd = fds[i];
 137
 138         ret = recvfrom(fd, buf, strlen("Yay!"), 0,
 139                        (void *)&remote_addr, &addlen);
 140         ok1(ret == strlen("Yay!"));
 141         ok1(memcmp(buf, "Yay!", ret) == 0);
 142         ret = sendto(fd, "metoo", strlen("metoo"), 0,
 143                      (void *)&remote_addr, addlen);
 144         ok1(ret == strlen("metoo"));
 145         ok1(wait(&status) >= 0);
 146         ok1(WIFEXITED(status));
 147         ok1(WEXITSTATUS(status) == 0);
 148         close(fd);
 149         for (i = 0; i < num_fds; i++)
 150                 close(fds[i]);
 151
 152 /* This seems like a Linux-only extension */
 153 #ifdef IPV6_V6ONLY
 154         /* Try to force separate sockets for IPv4/IPv6, if we can. */
 155         if (addr->ai_next)
 156                 ipv6_only = true;
 157 #endif
 158
 159         if (ipv6_only) {
 160                 int j;
 161
 162                 addr = net_server_lookup(TEST_PORT, AF_UNSPEC, SOCK_STREAM);
 163                 ok1(addr);
 164                 num_fds = net_bind(addr, fds);
 165                 ok1(num_fds == 2);
 166                 freeaddrinfo(addr);
 167
 168                 if (!fork()) {
 169                         for (i = 0; i < num_fds; i++)
 170                                 close(fds[i]);
 171                         do_connect(AF_INET, SOCK_STREAM);
 172                         do_connect(AF_INET6, SOCK_STREAM);
 173                         exit(0);
 174                 }
 175
 176                 i = wait_for_readable(fds, num_fds);
 177                 ok1(i < num_fds);
 178                 fd = accept(fds[i], NULL, NULL);
 179                 ok1(fd >= 0);
 180
 181                 ret = read(fd, buf, strlen("Yay!"));
 182                 ok1(ret == strlen("Yay!"));
 183                 ok1(memcmp(buf, "Yay!", ret) == 0);
 184                 ret = write(fd, "metoo", strlen("metoo"));
 185                 ok1(ret == strlen("metoo"));
 186                 close(fd);
 187
 188                 j = wait_for_readable(fds, num_fds);
 189                 ok1(j < num_fds);
 190                 ok1(j != i);
 191                 fd = accept(fds[j], NULL, NULL);
 192                 ok1(fd >= 0);
 193
 194                 ret = read(fd, buf, strlen("Yay!"));
 195                 ok1(ret == strlen("Yay!"));
 196                 ok1(memcmp(buf, "Yay!", ret) == 0);
 197                 ret = write(fd, "metoo", strlen("metoo"));
 198                 ok1(ret == strlen("metoo"));
 199
 200                 ok1(wait(&status) >= 0);
 201                 ok1(WIFEXITED(status));
 202                 ok1(WEXITSTATUS(status) == 0);
 203                 close(fd);
 204         } else
 205                 skip(16, "No support for IPv6-only binding");
 206
 207         for (i = 0; i < num_fds; i++)
 208                 close(fds[i]);
 209
 210         /* This exits depending on whether all tests passed */
 211         return exit_status();
 212 }