1 /* $KAME: tcp.c,v 1.13 2003/09/02 22:49:21 itojun Exp $ */
4 * Copyright (C) 1997 and 1998 WIDE Project.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the project nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 #include <sys/param.h>
36 #include <sys/types.h>
37 #include <sys/socket.h>
38 #include <sys/ioctl.h>
51 #include <netinet/in.h>
52 #include <arpa/inet.h>
57 static char tcpbuf[16*1024];
58 /* bigger than MSS and may be lesser than window size */
59 static int tblen, tboff, oob_exists;
60 static fd_set readfds, writefds, exceptfds;
61 static char atmark_buf[2];
62 static pid_t cpid = (pid_t)0;
63 static pid_t ppid = (pid_t)0;
64 volatile time_t child_lastactive = (time_t)0;
65 static time_t parent_lastactive = (time_t)0;
67 static void sig_ctimeout(int);
68 static void sig_child(int);
69 static void notify_inactive(void);
70 static void notify_active(void);
71 static void send_data(int, int, const char *, int);
72 static void relay(int, int, const char *, int);
76 * - child side (ppid != 0) will send SIGUSR1 to parent every (FAITH_TIMEOUT/4)
77 * second if traffic is active. if traffic is inactive, don't send SIGUSR1.
78 * - parent side (ppid == 0) will check the last SIGUSR1 it have seen.
81 sig_ctimeout(int sig __unused)
83 /* parent side: record notification from the child */
85 syslog(LOG_DEBUG, "activity timer from child");
86 child_lastactive = time(NULL);
89 /* parent will terminate if child dies. */
91 sig_child(int sig __unused)
96 pid = wait3(&status, WNOHANG, (struct rusage *)0);
97 if (pid > 0 && WEXITSTATUS(status))
98 syslog(LOG_WARNING, "child %ld exit status 0x%x",
100 exit_success("terminate connection due to child termination");
108 /* only on parent side... */
112 /* parent side should check for timeout. */
115 syslog(LOG_DEBUG, "parent side %sactive, child side %sactive",
116 (FAITH_TIMEOUT < t - parent_lastactive) ? "in" : "",
117 (FAITH_TIMEOUT < t - child_lastactive) ? "in" : "");
120 if (FAITH_TIMEOUT < t - child_lastactive
121 && FAITH_TIMEOUT < t - parent_lastactive) {
122 /* both side timeouted */
123 signal(SIGCHLD, SIG_DFL);
126 exit_failure("connection timeout");
135 /* child side: notify parent of active traffic */
138 if (FAITH_TIMEOUT / 4 < t - child_lastactive) {
139 if (kill(ppid, SIGUSR1) < 0) {
140 exit_failure("terminate connection due to parent termination");
143 child_lastactive = t;
147 parent_lastactive = time(NULL);
152 send_data(int s_rcv, int s_snd, const char *service __unused, int direction)
157 cc = send(s_snd, atmark_buf, 1, MSG_OOB);
161 if (s_rcv >= FD_SETSIZE)
162 exit_failure("descriptor too big");
163 FD_SET(s_rcv, &exceptfds);
166 for (; tboff < tblen; tboff += cc) {
167 cc = write(s_snd, tcpbuf + tboff, tblen - tboff);
173 if (tblen >= sizeof(tcpbuf))
174 tblen = sizeof(tcpbuf) - 1;
175 tcpbuf[tblen] = '\0';
176 syslog(LOG_DEBUG, "from %s (%dbytes): %s",
177 direction == 1 ? "client" : "server", tblen, tcpbuf);
180 tblen = 0; tboff = 0;
181 if (s_snd >= FD_SETSIZE)
182 exit_failure("descriptor too big");
183 FD_CLR(s_snd, &writefds);
184 if (s_rcv >= FD_SETSIZE)
185 exit_failure("descriptor too big");
186 FD_SET(s_rcv, &readfds);
190 exit_failure("writing relay data failed: %s", strerror(errno));
191 if (s_snd >= FD_SETSIZE)
192 exit_failure("descriptor too big");
193 FD_SET(s_snd, &writefds);
197 relay(int s_rcv, int s_snd, const char *service, int direction)
199 int atmark, error, maxfd;
201 fd_set oreadfds, owritefds, oexceptfds;
206 fcntl(s_snd, F_SETFD, O_NONBLOCK);
207 oreadfds = readfds; owritefds = writefds; oexceptfds = exceptfds;
208 if (s_rcv >= FD_SETSIZE)
209 exit_failure("descriptor too big");
210 FD_SET(s_rcv, &readfds);
211 FD_SET(s_rcv, &exceptfds);
213 maxfd = (s_rcv > s_snd) ? s_rcv : s_snd;
216 tv.tv_sec = FAITH_TIMEOUT / 4;
219 owritefds = writefds;
220 oexceptfds = exceptfds;
221 error = select(maxfd + 1, &readfds, &writefds, &exceptfds, &tv);
225 exit_failure("select: %s", strerror(errno));
226 } else if (error == 0) {
228 writefds = owritefds;
229 exceptfds = oexceptfds;
234 /* activity notification */
237 if (FD_ISSET(s_rcv, &exceptfds)) {
238 error = ioctl(s_rcv, SIOCATMARK, &atmark);
239 if (error != -1 && atmark == 1) {
242 cc = read(s_rcv, atmark_buf, 1);
244 if (s_rcv >= FD_SETSIZE)
245 exit_failure("descriptor too big");
246 FD_CLR(s_rcv, &exceptfds);
247 if (s_snd >= FD_SETSIZE)
248 exit_failure("descriptor too big");
249 FD_SET(s_snd, &writefds);
251 } else if (cc == -1) {
254 exit_failure("reading oob data failed"
260 if (FD_ISSET(s_rcv, &readfds)) {
261 relaydata_read_retry:
262 tblen = read(s_rcv, tcpbuf, sizeof(tcpbuf));
268 goto relaydata_read_retry;
269 exit_failure("reading relay data failed: %s",
273 /* to close opposite-direction relay process */
278 exit_success("terminating %s relay", service);
281 if (s_rcv >= FD_SETSIZE)
282 exit_failure("descriptor too big");
283 FD_CLR(s_rcv, &readfds);
284 if (s_snd >= FD_SETSIZE)
285 exit_failure("descriptor too big");
286 FD_SET(s_snd, &writefds);
290 if (FD_ISSET(s_snd, &writefds))
291 send_data(s_rcv, s_snd, service, direction);
296 tcp_relay(int s_src, int s_dst, const char *service)
298 syslog(LOG_INFO, "starting %s relay", service);
300 child_lastactive = parent_lastactive = time(NULL);
305 exit_failure("tcp_relay: can't fork grand child: %s",
309 /* child process: relay going traffic */
311 /* this is child so reopen log */
313 openlog(logname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
314 relay(s_src, s_dst, service, 1);
317 /* parent process: relay coming traffic */
319 signal(SIGUSR1, sig_ctimeout);
320 signal(SIGCHLD, sig_child);
321 relay(s_dst, s_src, service, 0);