tcpdrop: Drop a specific tcp connection or all tcp connections
authorSepherosa Ziehau <sephe@dragonflybsd.org>
Sun, 26 Jul 2015 09:20:18 +0000 (17:20 +0800)
committerSepherosa Ziehau <sephe@dragonflybsd.org>
Mon, 27 Jul 2015 01:42:00 +0000 (09:42 +0800)
Obtained-from: OpenBSD via FreeBSD

sys/netinet/tcp_subr.c
usr.sbin/Makefile
usr.sbin/tcpdrop/Makefile [new file with mode: 0644]
usr.sbin/tcpdrop/tcpdrop.8 [new file with mode: 0644]
usr.sbin/tcpdrop/tcpdrop.c [new file with mode: 0644]

index 07463b2..15b8f54 100644 (file)
@@ -2293,3 +2293,144 @@ tcpsignature_apply(void *fstate, void *data, unsigned int len)
        return (0);
 }
 #endif /* TCP_SIGNATURE */
+
+static void
+tcp_drop_sysctl_dispatch(netmsg_t nmsg)
+{
+       struct lwkt_msg *lmsg = &nmsg->lmsg;
+       /* addrs[0] is a foreign socket, addrs[1] is a local one. */
+       struct sockaddr_storage *addrs = lmsg->u.ms_resultp;
+       int error;
+       struct sockaddr_in *fin, *lin;
+#ifdef INET6
+       struct sockaddr_in6 *fin6, *lin6;
+       struct in6_addr f6, l6;
+#endif
+       struct inpcb *inp;
+
+       switch (addrs[0].ss_family) {
+#ifdef INET6
+       case AF_INET6:
+               fin6 = (struct sockaddr_in6 *)&addrs[0];
+               lin6 = (struct sockaddr_in6 *)&addrs[1];
+               error = in6_embedscope(&f6, fin6, NULL, NULL);
+               if (error)
+                       goto done;
+               error = in6_embedscope(&l6, lin6, NULL, NULL);
+               if (error)
+                       goto done;
+               inp = in6_pcblookup_hash(&tcbinfo[mycpuid], &f6,
+                   fin6->sin6_port, &l6, lin6->sin6_port, FALSE, NULL);
+               break;
+#endif
+#ifdef INET
+       case AF_INET:
+               fin = (struct sockaddr_in *)&addrs[0];
+               lin = (struct sockaddr_in *)&addrs[1];
+               inp = in_pcblookup_hash(&tcbinfo[mycpuid], fin->sin_addr,
+                   fin->sin_port, lin->sin_addr, lin->sin_port, FALSE, NULL);
+               break;
+#endif
+       default:
+               /*
+                * Must not reach here, since the address family was
+                * checked in sysctl handler.
+                */
+               panic("unknown address family %d", addrs[0].ss_family);
+       }
+       if (inp != NULL) {
+               struct tcpcb *tp = intotcpcb(inp);
+
+               KASSERT((inp->inp_flags & INP_WILDCARD) == 0,
+                   ("in wildcard hash"));
+
+               if (tp == NULL) {
+                       error = ESRCH;
+                       goto done;
+               }
+               KASSERT((tp->t_flags & TF_LISTEN) == 0, ("listen socket"));
+               tcp_drop(tp, ECONNABORTED);
+               error = 0;
+       } else {
+               error = ESRCH;
+       }
+done:
+       lwkt_replymsg(lmsg, error);
+}
+
+static int
+sysctl_tcp_drop(SYSCTL_HANDLER_ARGS)
+{
+       /* addrs[0] is a foreign socket, addrs[1] is a local one. */
+       struct sockaddr_storage addrs[2];
+       struct sockaddr_in *fin, *lin;
+#ifdef INET6
+       struct sockaddr_in6 *fin6, *lin6;
+#endif
+       struct netmsg_base nmsg;
+       struct lwkt_msg *lmsg = &nmsg.lmsg;
+       struct lwkt_port *port = NULL;
+       int error;
+
+       fin = lin = NULL;
+#ifdef INET6
+       fin6 = lin6 = NULL;
+#endif
+       error = 0;
+
+       if (req->oldptr != NULL || req->oldlen != 0)
+               return (EINVAL);
+       if (req->newptr == NULL)
+               return (EPERM);
+       if (req->newlen < sizeof(addrs))
+               return (ENOMEM);
+       error = SYSCTL_IN(req, &addrs, sizeof(addrs));
+       if (error)
+               return (error);
+
+       switch (addrs[0].ss_family) {
+#ifdef INET6
+       case AF_INET6:
+               fin6 = (struct sockaddr_in6 *)&addrs[0];
+               lin6 = (struct sockaddr_in6 *)&addrs[1];
+               if (fin6->sin6_len != sizeof(struct sockaddr_in6) ||
+                   lin6->sin6_len != sizeof(struct sockaddr_in6))
+                       return (EINVAL);
+               if (IN6_IS_ADDR_V4MAPPED(&fin6->sin6_addr) ||
+                   IN6_IS_ADDR_V4MAPPED(&lin6->sin6_addr))
+                       return (EADDRNOTAVAIL);
+#if 0
+               error = sa6_embedscope(fin6, V_ip6_use_defzone);
+               if (error)
+                       return (error);
+               error = sa6_embedscope(lin6, V_ip6_use_defzone);
+               if (error)
+                       return (error);
+#endif
+               port = tcp6_addrport();
+               break;
+#endif
+#ifdef INET
+       case AF_INET:
+               fin = (struct sockaddr_in *)&addrs[0];
+               lin = (struct sockaddr_in *)&addrs[1];
+               if (fin->sin_len != sizeof(struct sockaddr_in) ||
+                   lin->sin_len != sizeof(struct sockaddr_in))
+                       return (EINVAL);
+               port = tcp_addrport(fin->sin_addr.s_addr, fin->sin_port,
+                   lin->sin_addr.s_addr, lin->sin_port);
+               break;
+#endif
+       default:
+               return (EINVAL);
+       }
+
+       netmsg_init(&nmsg, NULL, &curthread->td_msgport, 0,
+           tcp_drop_sysctl_dispatch);
+       lmsg->u.ms_resultp = addrs;
+       return lwkt_domsg(port, lmsg, 0);
+}
+
+SYSCTL_PROC(_net_inet_tcp, OID_AUTO, drop,
+    CTLTYPE_STRUCT | CTLFLAG_WR | CTLFLAG_SKIP, NULL,
+    0, sysctl_tcp_drop, "", "Drop TCP connection");
index d7fc406..961c7a9 100644 (file)
@@ -120,6 +120,7 @@ SUBDIR= 802_11 \
        sysvipcd \
        tcpdchk \
        tcpdmatch \
+       tcpdrop \
        tcpdump \
        timed \
        traceroute \
diff --git a/usr.sbin/tcpdrop/Makefile b/usr.sbin/tcpdrop/Makefile
new file mode 100644 (file)
index 0000000..2fc606a
--- /dev/null
@@ -0,0 +1,7 @@
+# $OpenBSD: Makefile,v 1.1 2004/04/26 19:51:20 markus Exp $
+# $FreeBSD$
+
+PROG=  tcpdrop
+MAN=   tcpdrop.8
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/tcpdrop/tcpdrop.8 b/usr.sbin/tcpdrop/tcpdrop.8
new file mode 100644 (file)
index 0000000..e453394
--- /dev/null
@@ -0,0 +1,95 @@
+.\"    $OpenBSD: tcpdrop.8,v 1.5 2004/05/24 13:57:31 jmc Exp $
+.\"
+.\" Copyright (c) 2009 Juli Mallett <jmallett@FreeBSD.org>
+.\" Copyright (c) 2004 Markus Friedl <markus@openbsd.org>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd July 26, 2015
+.Dt TCPDROP 8
+.Os
+.Sh NAME
+.Nm tcpdrop
+.Nd drop TCP connections
+.Sh SYNOPSIS
+.Nm tcpdrop
+.Ar local-address
+.Ar local-port
+.Ar foreign-address
+.Ar foreign-port
+.Nm tcpdrop
+.Op Fl l
+.Fl a
+.Sh DESCRIPTION
+The
+.Nm
+command may be used to drop TCP connections from the command line.
+.Pp
+If
+.Fl a
+is specified then
+.Nm
+will attempt to drop all active connections.
+The
+.Fl l
+flag may be given to list the tcpdrop invocation to drop all active
+connections one at a time.
+.Pp
+If
+.Fl a
+is not specified then only the connection between the given local
+address
+.Ar local-address ,
+port
+.Ar local-port ,
+and the foreign address
+.Ar foreign-address ,
+port
+.Ar foreign-port ,
+will be dropped.
+.Pp
+Addresses and ports may be specified by name or numeric value.
+Both IPv4 and IPv6 address formats are supported.
+.Pp
+The addresses and ports may be separated by periods or colons
+instead of spaces.
+.Sh EXIT STATUS
+.Ex -std
+.Sh EXAMPLES
+If a connection to
+.Xr httpd 8
+is causing congestion on a network link, one can drop the TCP session
+in charge:
+.Bd -literal -offset indent
+# sockstat -c | grep httpd
+www      httpd      16525 3  tcp4 \e
+       192.168.5.41:80      192.168.5.1:26747
+.Ed
+.Pp
+The following command will drop the connection:
+.Bd -literal -offset indent
+# tcpdrop 192.168.5.41 80 192.168.5.1 26747
+.Ed
+.Pp
+The following command will drop all connections but those to or from
+port 22, the port used by
+.Xr sshd 8 :
+.Bd -literal -offset indent
+# tcpdrop -l -a | grep -vw 22 | sh
+.Ed
+.Sh SEE ALSO
+.Xr netstat 1 ,
+.Xr sockstat 1
+.Sh AUTHORS
+.An Markus Friedl Aq Mt markus@openbsd.org
+.An Juli Mallett Aq Mt jmallett@FreeBSD.org
diff --git a/usr.sbin/tcpdrop/tcpdrop.c b/usr.sbin/tcpdrop/tcpdrop.c
new file mode 100644 (file)
index 0000000..5f1d36b
--- /dev/null
@@ -0,0 +1,355 @@
+/* $OpenBSD: tcpdrop.c,v 1.4 2004/05/22 23:55:22 deraadt Exp $ */
+
+/*-
+ * Copyright (c) 2009 Juli Mallett <jmallett@FreeBSD.org>
+ * Copyright (c) 2004 Markus Friedl <markus@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/sysctl.h>
+
+#include <netinet/in.h>
+#include <netinet/in_pcb.h>
+#define TCPSTATES
+#include <netinet/tcp_fsm.h>
+#include <netinet/tcp_var.h>
+
+#include <err.h>
+#include <netdb.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define        TCPDROP_FOREIGN         0
+#define        TCPDROP_LOCAL           1
+
+struct host_service {
+       char hs_host[NI_MAXHOST];
+       char hs_service[NI_MAXSERV];
+};
+
+static bool tcpdrop_list_commands = false;
+
+static char *findport(const char *);
+static struct xtcpcb *tcpcblist(const char *, size_t *);
+static void sockinfo(const struct sockaddr *, struct host_service *);
+static bool tcpdrop(const struct sockaddr *, const struct sockaddr *);
+static bool tcpdropall(void);
+static bool tcpdropbyname(const char *, const char *, const char *,
+    const char *);
+static bool tcpdropconn(const struct in_conninfo *);
+static void usage(void);
+
+/*
+ * Drop a tcp connection.
+ */
+int
+main(int argc, char *argv[])
+{
+       char *lport, *fport;
+       bool dropall;
+       int ch;
+
+       dropall = false;
+
+       while ((ch = getopt(argc, argv, "al")) != -1) {
+               switch (ch) {
+               case 'a':
+                       dropall = true;
+                       break;
+               case 'l':
+                       tcpdrop_list_commands = true;
+                       break;
+               default:
+                       usage();
+               }
+       }
+       argc -= optind;
+       argv += optind;
+
+       if (dropall) {
+               if (argc != 0)
+                       usage();
+               if (!tcpdropall())
+                       exit(1);
+               exit(0);
+       }
+
+       if ((argc != 2 && argc != 4) || tcpdrop_list_commands)
+               usage();
+
+       if (argc == 2) {
+               lport = findport(argv[0]);
+               fport = findport(argv[1]);
+               if (lport == NULL || lport[1] == '\0' || fport == NULL ||
+                   fport[1] == '\0')
+                       usage();
+               *lport++ = '\0';
+               *fport++ = '\0';
+               if (!tcpdropbyname(argv[0], lport, argv[1], fport))
+                       exit(1);
+       } else if (!tcpdropbyname(argv[0], argv[1], argv[2], argv[3]))
+               exit(1);
+
+       exit(0);
+}
+
+static char *
+findport(const char *arg)
+{
+       char *dot, *colon;
+
+       /* A strrspn() or strrpbrk() would be nice. */
+       dot = strrchr(arg, '.');
+       colon = strrchr(arg, ':');
+       if (dot == NULL)
+               return (colon);
+       if (colon == NULL)
+               return (dot);
+       if (dot < colon)
+               return (colon);
+       else
+               return (dot);
+}
+
+static struct xtcpcb *
+tcpcblist(const char *name, size_t *len0)
+{
+       struct xtcpcb *tcp;
+       size_t len;
+       int rv;
+
+       len = 0;
+       rv = sysctlbyname(name, NULL, &len, NULL, 0);
+       if (rv == -1)
+               err(1, "sysctlbyname %s", name);
+
+       if (len == 0)
+               errx(1, "%s is empty", name);
+
+       tcp = malloc(len);
+       if (tcp == NULL)
+               errx(1, "malloc failed");
+
+       rv = sysctlbyname(name, tcp, &len, NULL, 0);
+       if (rv == -1)
+               err(1, "sysctlbyname %s", name);
+
+       *len0 = len;
+       return (tcp);
+}
+
+static void
+sockinfo(const struct sockaddr *sa, struct host_service *hs)
+{
+       static const int flags = NI_NUMERICHOST | NI_NUMERICSERV;
+       int rv;
+
+       rv = getnameinfo(sa, sa->sa_len, hs->hs_host, sizeof hs->hs_host,
+           hs->hs_service, sizeof hs->hs_service, flags);
+       if (rv == -1)
+               err(1, "getnameinfo");
+}
+
+static bool
+tcpdrop(const struct sockaddr *lsa, const struct sockaddr *fsa)
+{
+       struct host_service local, foreign;
+       struct sockaddr_storage addrs[2];
+       int rv;
+
+       memcpy(&addrs[TCPDROP_FOREIGN], fsa, fsa->sa_len);
+       memcpy(&addrs[TCPDROP_LOCAL], lsa, lsa->sa_len);
+
+       sockinfo(lsa, &local);
+       sockinfo(fsa, &foreign);
+
+       if (tcpdrop_list_commands) {
+               printf("tcpdrop %s %s %s %s\n", local.hs_host, local.hs_service,
+                   foreign.hs_host, foreign.hs_service);
+               return (true);
+       }
+
+       rv = sysctlbyname("net.inet.tcp.drop", NULL, NULL, &addrs,
+           sizeof addrs);
+       if (rv == -1) {
+               warn("%s %s %s %s", local.hs_host, local.hs_service,
+                   foreign.hs_host, foreign.hs_service);
+               return (false);
+       }
+       printf("%s %s %s %s: dropped\n", local.hs_host, local.hs_service,
+           foreign.hs_host, foreign.hs_service);
+       return (true);
+}
+
+static bool
+tcpdropall(void)
+{
+       struct xtcpcb *tcp;
+       size_t len;
+       bool ok;
+       int cnt, i;
+
+       ok = true;
+
+       tcp = tcpcblist("net.inet.tcp.pcblist", &len);
+       cnt = len / sizeof(*tcp);
+
+       for (i = 0; i < cnt; ++i) {
+               struct xtcpcb *xpcb;
+               struct tcpcb *tp;
+               struct inpcb *inp;
+
+               xpcb = &tcp[i];
+               if (xpcb->xt_len != sizeof(*xpcb))
+                       break;
+
+               tp = &xpcb->xt_tp;
+               inp = &xpcb->xt_inp;
+
+               /*
+                * XXX
+                * Check protocol, support just v4 or v6, etc.
+                */
+
+               /* Skip listening sockets.  */
+               if (tp->t_state == TCPS_LISTEN)
+                       continue;
+
+               if (!tcpdropconn(&inp->inp_inc))
+                       ok = false;
+       }
+       free(tcp);
+
+       return (ok);
+}
+
+static bool
+tcpdropbyname(const char *lhost, const char *lport, const char *fhost,
+    const char *fport)
+{
+       static const struct addrinfo hints = {
+               /*
+                * Look for streams in all domains.
+                */
+               .ai_family = AF_UNSPEC,
+               .ai_socktype = SOCK_STREAM,
+       };
+       struct addrinfo *ail, *local, *aif, *foreign;
+       int error;
+       bool ok, infamily;
+
+       error = getaddrinfo(lhost, lport, &hints, &local);
+       if (error != 0)
+               errx(1, "getaddrinfo: %s port %s: %s", lhost, lport,
+                   gai_strerror(error));
+
+       error = getaddrinfo(fhost, fport, &hints, &foreign);
+       if (error != 0) {
+               freeaddrinfo(local); /* XXX gratuitous */
+               errx(1, "getaddrinfo: %s port %s: %s", fhost, fport,
+                   gai_strerror(error));
+       }
+
+       ok = true;
+       infamily = false;
+
+       /*
+        * Try every combination of local and foreign address pairs.
+        */
+       for (ail = local; ail != NULL; ail = ail->ai_next) {
+               for (aif = foreign; aif != NULL; aif = aif->ai_next) {
+                       if (ail->ai_family != aif->ai_family)
+                               continue;
+                       infamily = true;
+                       if (!tcpdrop(ail->ai_addr, aif->ai_addr))
+                               ok = false;
+               }
+       }
+
+       if (!infamily) {
+               warnx("%s %s %s %s: different address families", lhost, lport,
+                   fhost, fport);
+               ok = false;
+       }
+
+       freeaddrinfo(local);
+       freeaddrinfo(foreign);
+
+       return (ok);
+}
+
+static bool
+tcpdropconn(const struct in_conninfo *inc)
+{
+       struct sockaddr *local, *foreign;
+       struct sockaddr_in6 sin6[2];
+       struct sockaddr_in sin4[2];
+
+       if (inc->inc_isipv6) {
+               memset(sin6, 0, sizeof sin6);
+
+               sin6[TCPDROP_LOCAL].sin6_len = sizeof sin6[TCPDROP_LOCAL];
+               sin6[TCPDROP_LOCAL].sin6_family = AF_INET6;
+               sin6[TCPDROP_LOCAL].sin6_port = inc->inc_lport;
+               memcpy(&sin6[TCPDROP_LOCAL].sin6_addr, &inc->inc6_laddr,
+                   sizeof inc->inc6_laddr);
+               local = (struct sockaddr *)&sin6[TCPDROP_LOCAL];
+
+               sin6[TCPDROP_FOREIGN].sin6_len = sizeof sin6[TCPDROP_FOREIGN];
+               sin6[TCPDROP_FOREIGN].sin6_family = AF_INET6;
+               sin6[TCPDROP_FOREIGN].sin6_port = inc->inc_fport;
+               memcpy(&sin6[TCPDROP_FOREIGN].sin6_addr, &inc->inc6_faddr,
+                   sizeof inc->inc6_faddr);
+               foreign = (struct sockaddr *)&sin6[TCPDROP_FOREIGN];
+       } else {
+               memset(&sin4[TCPDROP_LOCAL], 0, sizeof sin4[TCPDROP_LOCAL]);
+
+               sin4[TCPDROP_LOCAL].sin_len = sizeof sin4[TCPDROP_LOCAL];
+               sin4[TCPDROP_LOCAL].sin_family = AF_INET;
+               sin4[TCPDROP_LOCAL].sin_port = inc->inc_lport;
+               memcpy(&sin4[TCPDROP_LOCAL].sin_addr, &inc->inc_laddr,
+                   sizeof inc->inc_laddr);
+               local = (struct sockaddr *)&sin4[TCPDROP_LOCAL];
+
+               sin4[TCPDROP_FOREIGN].sin_len = sizeof sin4[TCPDROP_FOREIGN];
+               sin4[TCPDROP_FOREIGN].sin_family = AF_INET;
+               sin4[TCPDROP_FOREIGN].sin_port = inc->inc_fport;
+               memcpy(&sin4[TCPDROP_FOREIGN].sin_addr, &inc->inc_faddr,
+                   sizeof inc->inc_faddr);
+               foreign = (struct sockaddr *)&sin4[TCPDROP_FOREIGN];
+       }
+
+       return (tcpdrop(local, foreign));
+}
+
+static void
+usage(void)
+{
+       fprintf(stderr,
+"usage: tcpdrop local-address local-port foreign-address foreign-port\n"
+"       tcpdrop local-address:local-port foreign-address:foreign-port\n"
+"       tcpdrop local-address.local-port foreign-address.foreign-port\n"
+"       tcpdrop [-l] -a\n");
+       exit(1);
+}