1 /* $KAME: tcp.c,v 1.8 2001/11/21 07:40:22 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
31 * $FreeBSD: src/usr.sbin/faithd/tcp.c,v 1.1.2.3 2002/04/28 05:40:29 suz Exp $
32 * $DragonFly: src/usr.sbin/faithd/tcp.c,v 1.4 2003/11/16 14:10:45 eirikn Exp $
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.
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. */
96 pid = wait3(&status, WNOHANG, (struct rusage *)0);
97 if (pid && WEXITSTATUS(status))
98 syslog(LOG_WARNING, "child %d exit status 0x%x", pid, status);
99 exit_success("terminate connection due to child termination");
103 notify_inactive(void)
107 /* only on parent side... */
111 /* parent side should check for timeout. */
114 syslog(LOG_DEBUG, "parent side %sactive, child side %sactive",
115 (FAITH_TIMEOUT < t - parent_lastactive) ? "in" : "",
116 (FAITH_TIMEOUT < t - child_lastactive) ? "in" : "");
119 if (FAITH_TIMEOUT < t - child_lastactive
120 && FAITH_TIMEOUT < t - parent_lastactive) {
121 /* both side timeouted */
122 signal(SIGCHLD, SIG_DFL);
125 exit_failure("connection timeout");
134 /* child side: notify parent of active traffic */
137 if (FAITH_TIMEOUT / 4 < t - child_lastactive) {
138 if (kill(ppid, SIGUSR1) < 0) {
139 exit_failure("terminate connection due to parent termination");
142 child_lastactive = t;
146 parent_lastactive = time(NULL);
151 send_data(int s_rcv, int s_snd, const char *service, int direction)
156 cc = send(s_snd, atmark_buf, 1, MSG_OOB);
160 FD_SET(s_rcv, &exceptfds);
163 for (; tboff < tblen; tboff += cc) {
164 cc = write(s_snd, tcpbuf + tboff, tblen - tboff);
170 if (tblen >= sizeof(tcpbuf))
171 tblen = sizeof(tcpbuf) - 1;
172 tcpbuf[tblen] = '\0';
173 syslog(LOG_DEBUG, "from %s (%dbytes): %s",
174 direction == 1 ? "client" : "server", tblen, tcpbuf);
177 tblen = 0; tboff = 0;
178 FD_CLR(s_snd, &writefds);
179 FD_SET(s_rcv, &readfds);
183 exit_failure("writing relay data failed: %s", strerror(errno));
184 FD_SET(s_snd, &writefds);
188 relay(int s_rcv, int s_snd, const char *service, int direction)
190 int atmark, error, maxfd;
192 fd_set oreadfds, owritefds, oexceptfds;
197 fcntl(s_snd, F_SETFD, O_NONBLOCK);
198 oreadfds = readfds; owritefds = writefds; oexceptfds = exceptfds;
199 FD_SET(s_rcv, &readfds);
200 FD_SET(s_rcv, &exceptfds);
202 maxfd = (s_rcv > s_snd) ? s_rcv : s_snd;
205 tv.tv_sec = FAITH_TIMEOUT / 4;
208 owritefds = writefds;
209 oexceptfds = exceptfds;
210 error = select(maxfd + 1, &readfds, &writefds, &exceptfds, &tv);
214 exit_failure("select: %s", strerror(errno));
215 } else if (error == 0) {
217 writefds = owritefds;
218 exceptfds = oexceptfds;
223 /* activity notification */
226 if (FD_ISSET(s_rcv, &exceptfds)) {
227 error = ioctl(s_rcv, SIOCATMARK, &atmark);
228 if (error != -1 && atmark == 1) {
231 cc = read(s_rcv, atmark_buf, 1);
233 FD_CLR(s_rcv, &exceptfds);
234 FD_SET(s_snd, &writefds);
236 } else if (cc == -1) {
239 exit_failure("reading oob data failed"
245 if (FD_ISSET(s_rcv, &readfds)) {
246 relaydata_read_retry:
247 tblen = read(s_rcv, tcpbuf, sizeof(tcpbuf));
253 goto relaydata_read_retry;
254 exit_failure("reading relay data failed: %s",
258 /* to close opposite-direction relay process */
263 exit_success("terminating %s relay", service);
266 FD_CLR(s_rcv, &readfds);
267 FD_SET(s_snd, &writefds);
271 if (FD_ISSET(s_snd, &writefds))
272 send_data(s_rcv, s_snd, service, direction);
277 tcp_relay(int s_src, int s_dst, const char *service)
279 syslog(LOG_INFO, "starting %s relay", service);
281 child_lastactive = parent_lastactive = time(NULL);
286 exit_failure("tcp_relay: can't fork grand child: %s",
290 /* child process: relay going traffic */
292 /* this is child so reopen log */
294 openlog(logname, LOG_PID | LOG_NOWAIT, LOG_DAEMON);
295 relay(s_src, s_dst, service, 1);
298 /* parent process: relay coming traffic */
300 signal(SIGUSR1, sig_ctimeout);
301 signal(SIGCHLD, sig_child);
302 relay(s_dst, s_src, service, 0);