1 /* $OpenBSD: tcpdrop.c,v 1.4 2004/05/22 23:55:22 deraadt Exp $ */ 2 3 /*- 4 * Copyright (c) 2009 Juli Mallett <jmallett@FreeBSD.org> 5 * Copyright (c) 2004 Markus Friedl <markus@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <sys/cdefs.h> 21 __FBSDID("$FreeBSD$"); 22 23 #include <sys/param.h> 24 #include <sys/types.h> 25 #include <sys/socket.h> 26 #include <sys/socketvar.h> 27 #include <sys/sysctl.h> 28 29 #include <netinet/in.h> 30 #include <netinet/in_pcb.h> 31 #define TCPSTATES 32 #include <netinet/tcp_fsm.h> 33 #include <netinet/tcp_var.h> 34 35 #include <err.h> 36 #include <netdb.h> 37 #include <stdbool.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <unistd.h> 42 43 #define TCPDROP_FOREIGN 0 44 #define TCPDROP_LOCAL 1 45 46 struct host_service { 47 char hs_host[NI_MAXHOST]; 48 char hs_service[NI_MAXSERV]; 49 }; 50 51 static bool tcpdrop_list_commands = false; 52 53 static char *findport(const char *); 54 static struct xinpgen *getxpcblist(const char *); 55 static void sockinfo(const struct sockaddr *, struct host_service *); 56 static bool tcpdrop(const struct sockaddr *, const struct sockaddr *); 57 static bool tcpdropall(const char *, int); 58 static bool tcpdropbyname(const char *, const char *, const char *, 59 const char *); 60 static bool tcpdropconn(const struct in_conninfo *); 61 static void usage(void); 62 63 /* 64 * Drop a tcp connection. 65 */ 66 int 67 main(int argc, char *argv[]) 68 { 69 char stack[TCP_FUNCTION_NAME_LEN_MAX]; 70 char *lport, *fport; 71 bool dropall, dropallstack; 72 int ch, state; 73 74 dropall = false; 75 dropallstack = false; 76 stack[0] = '\0'; 77 state = -1; 78 79 while ((ch = getopt(argc, argv, "alS:s:")) != -1) { 80 switch (ch) { 81 case 'a': 82 dropall = true; 83 break; 84 case 'l': 85 tcpdrop_list_commands = true; 86 break; 87 case 'S': 88 dropallstack = true; 89 strlcpy(stack, optarg, sizeof(stack)); 90 break; 91 case 's': 92 dropallstack = true; 93 for (state = 0; state < TCP_NSTATES; state++) { 94 if (strcmp(tcpstates[state], optarg) == 0) 95 break; 96 } 97 break; 98 default: 99 usage(); 100 } 101 } 102 argc -= optind; 103 argv += optind; 104 105 if (state == TCP_NSTATES || 106 state == TCPS_CLOSED || 107 state == TCPS_LISTEN) 108 usage(); 109 if (dropall && dropallstack) 110 usage(); 111 if (dropall || dropallstack) { 112 if (argc != 0) 113 usage(); 114 if (!tcpdropall(stack, state)) 115 exit(1); 116 exit(0); 117 } 118 119 if ((argc != 2 && argc != 4) || tcpdrop_list_commands) 120 usage(); 121 122 if (argc == 2) { 123 lport = findport(argv[0]); 124 fport = findport(argv[1]); 125 if (lport == NULL || lport[1] == '\0' || fport == NULL || 126 fport[1] == '\0') 127 usage(); 128 *lport++ = '\0'; 129 *fport++ = '\0'; 130 if (!tcpdropbyname(argv[0], lport, argv[1], fport)) 131 exit(1); 132 } else if (!tcpdropbyname(argv[0], argv[1], argv[2], argv[3])) 133 exit(1); 134 135 exit(0); 136 } 137 138 static char * 139 findport(const char *arg) 140 { 141 char *dot, *colon; 142 143 /* A strrspn() or strrpbrk() would be nice. */ 144 dot = strrchr(arg, '.'); 145 colon = strrchr(arg, ':'); 146 if (dot == NULL) 147 return (colon); 148 if (colon == NULL) 149 return (dot); 150 if (dot < colon) 151 return (colon); 152 else 153 return (dot); 154 } 155 156 static struct xinpgen * 157 getxpcblist(const char *name) 158 { 159 struct xinpgen *xinp; 160 size_t len; 161 int rv; 162 163 len = 0; 164 rv = sysctlbyname(name, NULL, &len, NULL, 0); 165 if (rv == -1) 166 err(1, "sysctlbyname %s", name); 167 168 if (len == 0) 169 errx(1, "%s is empty", name); 170 171 xinp = malloc(len); 172 if (xinp == NULL) 173 errx(1, "malloc failed"); 174 175 rv = sysctlbyname(name, xinp, &len, NULL, 0); 176 if (rv == -1) 177 err(1, "sysctlbyname %s", name); 178 179 return (xinp); 180 } 181 182 static void 183 sockinfo(const struct sockaddr *sa, struct host_service *hs) 184 { 185 static const int flags = NI_NUMERICHOST | NI_NUMERICSERV; 186 int rv; 187 188 rv = getnameinfo(sa, sa->sa_len, hs->hs_host, sizeof hs->hs_host, 189 hs->hs_service, sizeof hs->hs_service, flags); 190 if (rv == -1) 191 err(1, "getnameinfo"); 192 } 193 194 static bool 195 tcpdrop(const struct sockaddr *lsa, const struct sockaddr *fsa) 196 { 197 struct host_service local, foreign; 198 struct sockaddr_storage addrs[2]; 199 int rv; 200 201 memcpy(&addrs[TCPDROP_FOREIGN], fsa, fsa->sa_len); 202 memcpy(&addrs[TCPDROP_LOCAL], lsa, lsa->sa_len); 203 204 sockinfo(lsa, &local); 205 sockinfo(fsa, &foreign); 206 207 if (tcpdrop_list_commands) { 208 printf("tcpdrop %s %s %s %s\n", local.hs_host, local.hs_service, 209 foreign.hs_host, foreign.hs_service); 210 return (true); 211 } 212 213 rv = sysctlbyname("net.inet.tcp.drop", NULL, NULL, &addrs, 214 sizeof addrs); 215 if (rv == -1) { 216 warn("%s %s %s %s", local.hs_host, local.hs_service, 217 foreign.hs_host, foreign.hs_service); 218 return (false); 219 } 220 printf("%s %s %s %s: dropped\n", local.hs_host, local.hs_service, 221 foreign.hs_host, foreign.hs_service); 222 return (true); 223 } 224 225 static bool 226 tcpdropall(const char *stack, int state) 227 { 228 struct xinpgen *head, *xinp; 229 struct xtcpcb *xtp; 230 struct xinpcb *xip; 231 bool ok; 232 233 ok = true; 234 235 head = getxpcblist("net.inet.tcp.pcblist"); 236 237 #define XINP_NEXT(xinp) \ 238 ((struct xinpgen *)(uintptr_t)((uintptr_t)(xinp) + (xinp)->xig_len)) 239 240 for (xinp = XINP_NEXT(head); xinp->xig_len > sizeof *xinp; 241 xinp = XINP_NEXT(xinp)) { 242 xtp = (struct xtcpcb *)xinp; 243 xip = &xtp->xt_inp; 244 245 /* 246 * XXX 247 * Check protocol, support just v4 or v6, etc. 248 */ 249 250 /* Ignore PCBs which were freed during copyout. */ 251 if (xip->inp_gencnt > head->xig_gen) 252 continue; 253 254 /* Skip listening sockets. */ 255 if (xtp->t_state == TCPS_LISTEN) 256 continue; 257 258 /* If requested, skip sockets not having the requested state. */ 259 if ((state != -1) && (xtp->t_state != state)) 260 continue; 261 262 /* If requested, skip sockets not having the requested stack. */ 263 if (stack[0] != '\0' && 264 strncmp(xtp->xt_stack, stack, TCP_FUNCTION_NAME_LEN_MAX)) 265 continue; 266 267 if (!tcpdropconn(&xip->inp_inc)) 268 ok = false; 269 } 270 free(head); 271 272 return (ok); 273 } 274 275 static bool 276 tcpdropbyname(const char *lhost, const char *lport, const char *fhost, 277 const char *fport) 278 { 279 static const struct addrinfo hints = { 280 /* 281 * Look for streams in all domains. 282 */ 283 .ai_family = AF_UNSPEC, 284 .ai_socktype = SOCK_STREAM, 285 }; 286 struct addrinfo *ail, *local, *aif, *foreign; 287 int error; 288 bool ok, infamily; 289 290 error = getaddrinfo(lhost, lport, &hints, &local); 291 if (error != 0) 292 errx(1, "getaddrinfo: %s port %s: %s", lhost, lport, 293 gai_strerror(error)); 294 295 error = getaddrinfo(fhost, fport, &hints, &foreign); 296 if (error != 0) { 297 freeaddrinfo(local); /* XXX gratuitous */ 298 errx(1, "getaddrinfo: %s port %s: %s", fhost, fport, 299 gai_strerror(error)); 300 } 301 302 ok = true; 303 infamily = false; 304 305 /* 306 * Try every combination of local and foreign address pairs. 307 */ 308 for (ail = local; ail != NULL; ail = ail->ai_next) { 309 for (aif = foreign; aif != NULL; aif = aif->ai_next) { 310 if (ail->ai_family != aif->ai_family) 311 continue; 312 infamily = true; 313 if (!tcpdrop(ail->ai_addr, aif->ai_addr)) 314 ok = false; 315 } 316 } 317 318 if (!infamily) { 319 warnx("%s %s %s %s: different address families", lhost, lport, 320 fhost, fport); 321 ok = false; 322 } 323 324 freeaddrinfo(local); 325 freeaddrinfo(foreign); 326 327 return (ok); 328 } 329 330 static bool 331 tcpdropconn(const struct in_conninfo *inc) 332 { 333 struct sockaddr *local, *foreign; 334 struct sockaddr_in6 sin6[2]; 335 struct sockaddr_in sin4[2]; 336 337 if ((inc->inc_flags & INC_ISIPV6) != 0) { 338 memset(sin6, 0, sizeof sin6); 339 340 sin6[TCPDROP_LOCAL].sin6_len = sizeof sin6[TCPDROP_LOCAL]; 341 sin6[TCPDROP_LOCAL].sin6_family = AF_INET6; 342 sin6[TCPDROP_LOCAL].sin6_port = inc->inc_lport; 343 memcpy(&sin6[TCPDROP_LOCAL].sin6_addr, &inc->inc6_laddr, 344 sizeof inc->inc6_laddr); 345 local = (struct sockaddr *)&sin6[TCPDROP_LOCAL]; 346 347 sin6[TCPDROP_FOREIGN].sin6_len = sizeof sin6[TCPDROP_FOREIGN]; 348 sin6[TCPDROP_FOREIGN].sin6_family = AF_INET6; 349 sin6[TCPDROP_FOREIGN].sin6_port = inc->inc_fport; 350 memcpy(&sin6[TCPDROP_FOREIGN].sin6_addr, &inc->inc6_faddr, 351 sizeof inc->inc6_faddr); 352 foreign = (struct sockaddr *)&sin6[TCPDROP_FOREIGN]; 353 } else { 354 memset(sin4, 0, sizeof sin4); 355 356 sin4[TCPDROP_LOCAL].sin_len = sizeof sin4[TCPDROP_LOCAL]; 357 sin4[TCPDROP_LOCAL].sin_family = AF_INET; 358 sin4[TCPDROP_LOCAL].sin_port = inc->inc_lport; 359 memcpy(&sin4[TCPDROP_LOCAL].sin_addr, &inc->inc_laddr, 360 sizeof inc->inc_laddr); 361 local = (struct sockaddr *)&sin4[TCPDROP_LOCAL]; 362 363 sin4[TCPDROP_FOREIGN].sin_len = sizeof sin4[TCPDROP_FOREIGN]; 364 sin4[TCPDROP_FOREIGN].sin_family = AF_INET; 365 sin4[TCPDROP_FOREIGN].sin_port = inc->inc_fport; 366 memcpy(&sin4[TCPDROP_FOREIGN].sin_addr, &inc->inc_faddr, 367 sizeof inc->inc_faddr); 368 foreign = (struct sockaddr *)&sin4[TCPDROP_FOREIGN]; 369 } 370 371 return (tcpdrop(local, foreign)); 372 } 373 374 static void 375 usage(void) 376 { 377 fprintf(stderr, 378 "usage: tcpdrop local-address local-port foreign-address foreign-port\n" 379 " tcpdrop local-address:local-port foreign-address:foreign-port\n" 380 " tcpdrop local-address.local-port foreign-address.foreign-port\n" 381 " tcpdrop [-l] -a\n" 382 " tcpdrop [-l] -S stack\n" 383 " tcpdrop [-l] -s state\n" 384 " tcpdrop [-l] -S stack -s state\n"); 385 exit(1); 386 } 387