1 /*- 2 * Copyright (c) 2007 Robert N. M. Watson 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 #include <sys/select.h> 30 #include <sys/socket.h> 31 #include <sys/stat.h> 32 33 #include <netinet/in.h> 34 35 #include <arpa/inet.h> 36 37 #include <err.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <limits.h> 41 #include <stdio.h> 42 #include <string.h> 43 #include <unistd.h> 44 45 #define PORT1 10001 46 #define PORT2 10002 47 48 static void 49 try_0send(const char *test, int fd) 50 { 51 ssize_t len; 52 char ch; 53 54 ch = 0; 55 len = send(fd, &ch, 0, 0); 56 if (len < 0) 57 err(-1, "%s: try_0send", test); 58 if (len != 0) 59 errx(-1, "%s: try_0send: returned %zd", test, len); 60 } 61 62 static void 63 try_0write(const char *test, int fd) 64 { 65 ssize_t len; 66 char ch; 67 68 ch = 0; 69 len = write(fd, &ch, 0); 70 if (len < 0) 71 err(-1, "%s: try_0write", test); 72 if (len != 0) 73 errx(-1, "%s: try_0write: returned %zd", test, len); 74 } 75 76 static void 77 setup_udp(const char *test, int *fdp) 78 { 79 struct sockaddr_in sin; 80 int sock1, sock2; 81 82 bzero(&sin, sizeof(sin)); 83 sin.sin_len = sizeof(sin); 84 sin.sin_family = AF_INET; 85 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 86 87 sin.sin_port = htons(PORT1); 88 sock1 = socket(PF_INET, SOCK_DGRAM, 0); 89 if (sock1 < 0) 90 err(-1, "%s: setup_udp: socket", test); 91 if (bind(sock1, (struct sockaddr *)&sin, sizeof(sin)) < 0) 92 err(-1, "%s: setup_udp: bind(%s, %d)", test, 93 inet_ntoa(sin.sin_addr), PORT1); 94 sin.sin_port = htons(PORT2); 95 if (connect(sock1, (struct sockaddr *)&sin, sizeof(sin)) < 0) 96 err(-1, "%s: setup_udp: connect(%s, %d)", test, 97 inet_ntoa(sin.sin_addr), PORT2); 98 99 sock2 = socket(PF_INET, SOCK_DGRAM, 0); 100 if (sock2 < 0) 101 err(-1, "%s: setup_udp: socket", test); 102 if (bind(sock2, (struct sockaddr *)&sin, sizeof(sin)) < 0) 103 err(-1, "%s: setup_udp: bind(%s, %d)", test, 104 inet_ntoa(sin.sin_addr), PORT2); 105 sin.sin_port = htons(PORT1); 106 if (connect(sock2, (struct sockaddr *)&sin, sizeof(sin)) < 0) 107 err(-1, "%s: setup_udp: connect(%s, %d)", test, 108 inet_ntoa(sin.sin_addr), PORT1); 109 110 fdp[0] = sock1; 111 fdp[1] = sock2; 112 } 113 114 static void 115 setup_tcp(const char *test, int *fdp) 116 { 117 fd_set writefds, exceptfds; 118 struct sockaddr_in sin; 119 int ret, sock1, sock2, sock3; 120 struct timeval tv; 121 122 bzero(&sin, sizeof(sin)); 123 sin.sin_len = sizeof(sin); 124 sin.sin_family = AF_INET; 125 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 126 127 /* 128 * First set up the listen socket. 129 */ 130 sin.sin_port = htons(PORT1); 131 sock1 = socket(PF_INET, SOCK_STREAM, 0); 132 if (sock1 < 0) 133 err(-1, "%s: setup_tcp: socket", test); 134 if (bind(sock1, (struct sockaddr *)&sin, sizeof(sin)) < 0) 135 err(-1, "%s: bind(%s, %d)", test, inet_ntoa(sin.sin_addr), 136 PORT1); 137 if (listen(sock1, -1) < 0) 138 err(-1, "%s: listen", test); 139 140 /* 141 * Now connect to it, non-blocking so that we don't deadlock against 142 * ourselves. 143 */ 144 sock2 = socket(PF_INET, SOCK_STREAM, 0); 145 if (sock2 < 0) 146 err(-1, "%s: setup_tcp: socket", test); 147 if (fcntl(sock2, F_SETFL, O_NONBLOCK) < 0) 148 err(-1, "%s: setup_tcp: fcntl(O_NONBLOCK)", test); 149 if (connect(sock2, (struct sockaddr *)&sin, sizeof(sin)) < 0 && 150 errno != EINPROGRESS) 151 err(-1, "%s: setup_tcp: connect(%s, %d)", test, 152 inet_ntoa(sin.sin_addr), PORT1); 153 154 /* 155 * Now pick up the connection after sleeping a moment to make sure 156 * there's been time for some packets to go back and forth. 157 */ 158 if (sleep(1) < 0) 159 err(-1, "%s: sleep(1)", test); 160 sock3 = accept(sock1, NULL, NULL); 161 if (sock3 < 0) 162 err(-1, "%s: accept", test); 163 if (sleep(1) < 0) 164 err(-1, "%s: sleep(1)", test); 165 166 FD_ZERO(&writefds); 167 FD_SET(sock2, &writefds); 168 FD_ZERO(&exceptfds); 169 FD_SET(sock2, &exceptfds); 170 tv.tv_sec = 1; 171 tv.tv_usec = 0; 172 ret = select(sock2 + 1, NULL, &writefds, &exceptfds, &tv); 173 if (ret < 0) 174 err(-1, "%s: setup_tcp: select", test); 175 if (FD_ISSET(sock2, &exceptfds)) 176 errx(-1, "%s: setup_tcp: select: exception", test); 177 if (!FD_ISSET(sock2, &writefds)) 178 errx(-1, "%s: setup_tcp: select: not writable", test); 179 180 close(sock1); 181 fdp[0] = sock2; 182 fdp[1] = sock3; 183 } 184 185 static void 186 setup_udsstream(const char *test, int *fdp) 187 { 188 189 if (socketpair(PF_LOCAL, SOCK_STREAM, 0, fdp) < 0) 190 err(-1, "%s: setup_udsstream: socketpair", test); 191 } 192 193 static void 194 setup_udsdgram(const char *test, int *fdp) 195 { 196 197 if (socketpair(PF_LOCAL, SOCK_DGRAM, 0, fdp) < 0) 198 err(-1, "%s: setup_udsdgram: socketpair", test); 199 } 200 201 static void 202 setup_pipe(const char *test, int *fdp) 203 { 204 205 if (pipe(fdp) < 0) 206 err(-1, "%s: setup_pipe: pipe", test); 207 } 208 209 static void 210 setup_fifo(const char *test, int *fdp) 211 { 212 char path[PATH_MAX]; 213 int fd1, fd2; 214 215 strcpy(path, "/tmp/0send_fifo.XXXXXXX"); 216 if (mktemp(path) == NULL) 217 err(-1, "%s: setup_fifo: mktemp", test); 218 219 if (mkfifo(path, 0600) < 0) 220 err(-1, "%s: setup_fifo: mkfifo(%s)", test, path); 221 222 fd1 = open(path, O_RDONLY | O_NONBLOCK); 223 if (fd1 < 0) 224 err(-1, "%s: setup_fifo: open(%s, O_RDONLY)", test, path); 225 226 fd2 = open(path, O_WRONLY | O_NONBLOCK); 227 if (fd2 < 0) 228 err(-1, "%s: setup_fifo: open(%s, O_WRONLY)", test, path); 229 230 fdp[0] = fd2; 231 fdp[1] = fd1; 232 } 233 234 static void 235 close_both(int *fdp) 236 { 237 238 close(fdp[0]); 239 fdp[0] = -1; 240 close(fdp[1]); 241 fdp[1] = -1; 242 } 243 244 int 245 main(int argc, char *argv[]) 246 { 247 int fd[2]; 248 249 setup_udp("udp_0send", fd); 250 try_0send("udp_0send", fd[0]); 251 close_both(fd); 252 253 setup_udp("udp_0write", fd); 254 try_0write("udp_0write", fd[0]); 255 close_both(fd); 256 257 setup_tcp("tcp_0send", fd); 258 try_0send("tcp_0send", fd[0]); 259 close_both(fd); 260 261 setup_tcp("tcp_0write", fd); 262 try_0write("tcp_0write", fd[0]); 263 close_both(fd); 264 265 setup_udsstream("udsstream_0send", fd); 266 try_0send("udsstream_0send", fd[0]); 267 close_both(fd); 268 269 setup_udsstream("udsstream_0write", fd); 270 try_0write("udsstream_0write", fd[0]); 271 close_both(fd); 272 273 setup_udsdgram("udsdgram_0send", fd); 274 try_0send("udsdgram_0send", fd[0]); 275 close_both(fd); 276 277 setup_udsdgram("udsdgram_0write", fd); 278 try_0write("udsdgram_0write", fd[0]); 279 close_both(fd); 280 281 setup_pipe("pipe_0write", fd); 282 try_0write("pipd_0write", fd[0]); 283 close_both(fd); 284 285 setup_fifo("fifo_0write", fd); 286 try_0write("fifo_0write", fd[0]); 287 close_both(fd); 288 289 return (0); 290 } 291