├── .gitignore ├── LICENSE ├── Makefile ├── README.dsniff ├── README.md ├── patch-tcpkill.c.diff ├── pcaputil.c ├── pcaputil.h ├── tcpkill.8 ├── tcpkill.c └── version.h /.gitignore: -------------------------------------------------------------------------------- 1 | tcpkill 2 | *.o 3 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | 2 | Copyright (c) 1999-2010 Dug Song , et al. 3 | All rights reserved, all wrongs reversed. 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 | 9 | 1. Redistributions of source code must retain the above copyright 10 | notice, this list of conditions and the following disclaimer. 11 | 2. Redistributions in binary form must reproduce the above copyright 12 | notice, this list of conditions and the following disclaimer in the 13 | documentation and/or other materials provided with the distribution. 14 | 3. The names of authors may not be used to endorse or promote products 15 | derived from this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 | INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 19 | AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 20 | THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 23 | OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 | WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 25 | OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 26 | ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | 28 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | .PHONY: clean 2 | LDFLAGS = -lpcap -lnet 3 | CFLAGS = -Wall 4 | 5 | tcpkill: pcaputil.o tcpkill.c 6 | ${CC} ${CFLAGS} ${LDFLAGS} -o $@ $^ 7 | 8 | clean: 9 | rm -f pcaputil.o tcpkill 10 | -------------------------------------------------------------------------------- /README.dsniff: -------------------------------------------------------------------------------- 1 | 2 | dsniff-2.3 3 | ---------- 4 | 5 | i wrote these tools with honest intentions - to audit my own network, 6 | and to demonstrate the insecurity of cleartext / weakly-encrypted 7 | network protocols and ad-hoc PKI. please do not abuse this software. 8 | 9 | these programs require: 10 | 11 | Berkeley DB - http://www.sleepycat.com/ 12 | OpenSSL - http://www.openssl.org/ 13 | libpcap - http://www.tcpdump.org/ 14 | libnids - http://www.packetfactory.net/Projects/Libnids/ 15 | libnet - http://www.packetfactory.net/Projects/Libnet/ 16 | 17 | built and tested on OpenBSD, Linux, and Solaris. YMMV. 18 | 19 | what's here: 20 | 21 | arpspoof 22 | redirect packets from a target host (or all hosts) on the LAN 23 | intended for another local host by forging ARP replies. this 24 | is an extremely effective way of sniffing traffic on a switch. 25 | kernel IP forwarding (or a userland program which accomplishes 26 | the same, e.g. fragrouter :-) must be turned on ahead of time. 27 | 28 | dnsspoof 29 | forge replies to arbitrary DNS address / pointer queries on 30 | the LAN. this is useful in bypassing hostname-based access 31 | controls, or in implementing a variety of man-in-the-middle 32 | attacks (HTTP, HTTPS, SSH, Kerberos, etc). 33 | 34 | dsniff 35 | password sniffer. handles FTP, Telnet, SMTP, HTTP, POP, 36 | poppass, NNTP, IMAP, SNMP, LDAP, Rlogin, RIP, OSPF, PPTP 37 | MS-CHAP, NFS, VRRP, YP/NIS, SOCKS, X11, CVS, IRC, AIM, ICQ, 38 | Napster, PostgreSQL, Meeting Maker, Citrix ICA, Symantec 39 | pcAnywhere, NAI Sniffer, Microsoft SMB, Oracle SQL*Net, Sybase 40 | and Microsoft SQL auth info. 41 | 42 | dsniff automatically detects and minimally parses each 43 | application protocol, only saving the interesting bits, and 44 | uses Berkeley DB as its output file format, only logging 45 | unique authentication attempts. full TCP/IP reassembly is 46 | provided by libnids(3) (likewise for the following tools as 47 | well). 48 | 49 | filesnarf 50 | saves selected files sniffed from NFS traffic in the current 51 | working directory. 52 | 53 | macof 54 | flood the local network with random MAC addresses (causing 55 | some switches to fail open in repeating mode, facilitating 56 | sniffing). a straight C port of the original Perl Net::RawIP 57 | macof program. 58 | 59 | mailsnarf 60 | a fast and easy way to violate the Electronic Communications 61 | Privacy Act of 1986 (18 USC 2701-2711), be careful. outputs 62 | selected messages sniffed from SMTP and POP traffic in Berkeley 63 | mbox format, suitable for offline browsing with your favorite 64 | mail reader (mail -f, pine, etc.). 65 | 66 | msgsnarf 67 | record selected messages from sniffed AOL Instant Messenger, 68 | ICQ 2000, IRC, and Yahoo! Messenger chat sessions. 69 | 70 | sshmitm 71 | SSH monkey-in-the-middle. proxies and sniffs SSH traffic 72 | redirected by dnsspoof(8), capturing SSH password logins, and 73 | optionally hijacking interactive sessions. only SSH protocol 74 | version 1 is (or ever will be) supported - this program is far 75 | too evil already. 76 | 77 | sshow 78 | SSH traffic analysis tool. analyzes encrypted SSH-1 and SSH-2 79 | traffic, identifying authentication attempts, the lengths of 80 | passwords entered in interactive sessions, and command line 81 | lengths. 82 | 83 | tcpkill 84 | kills specified in-progress TCP connections (useful for 85 | libnids-based applications which require a full TCP 3-whs for 86 | TCB creation). 87 | 88 | tcpnice 89 | slow down specified TCP connections via "active" traffic 90 | shaping. forges tiny TCP window advertisements, and optionally 91 | ICMP source quench replies. 92 | 93 | urlsnarf 94 | output selected URLs sniffed from HTTP traffic in CLF 95 | (Common Log Format, used by almost all web servers), suitable 96 | for offline post-processing with your favorite web log 97 | analysis tool (analog, wwwstat, etc.). 98 | 99 | webmitm 100 | HTTP / HTTPS monkey-in-the-middle. transparently proxies and 101 | sniffs web traffic redirected by dnsspoof(8), capturing most 102 | "secure" SSL-encrypted webmail logins and form submissions. 103 | 104 | webspy 105 | sends URLs sniffed from a client to your local Netscape 106 | browser for display, updated in real-time (as the target 107 | surfs, your browser surfs along with them, automagically). 108 | a fun party trick. :-) 109 | 110 | -d. 111 | 112 | --- 113 | http://www.monkey.org/~dugsong/ 114 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Slightly modified tcpkill util 2 | ([original](http://monkey.org/~dugsong/dsniff/)), to allow for only 3 | killing a specific number of connections. 4 | 5 | tcpkill 6 | kills specified in-progress TCP connections (useful for 7 | libnids-based applications which require a full TCP 3-whs for 8 | TCB creation). 9 | -------------------------------------------------------------------------------- /patch-tcpkill.c.diff: -------------------------------------------------------------------------------- 1 | --- tcpkill.c.orig 2009-09-08 23:51:15.000000000 +0200 2 | +++ tcpkill.c 2009-09-09 00:02:18.000000000 +0200 3 | @@ -39,17 +39,18 @@ 4 | static void 5 | tcp_kill_cb(u_char *user, const struct pcap_pkthdr *pcap, const u_char *pkt) 6 | { 7 | - struct libnet_ip_hdr *ip; 8 | + struct libnet_ipv4_hdr *ip; 9 | struct libnet_tcp_hdr *tcp; 10 | - u_char ctext[64], buf[IP_H + TCP_H]; 11 | + u_char ctext[64]; 12 | u_int32_t seq, win; 13 | - int i, *sock, len; 14 | + int i, len; 15 | + libnet_t *l; 16 | 17 | - sock = (int *)user; 18 | + l = (libnet_t *)user; 19 | pkt += pcap_off; 20 | len = pcap->caplen - pcap_off; 21 | 22 | - ip = (struct libnet_ip_hdr *)pkt; 23 | + ip = (struct libnet_ipv4_hdr *)pkt; 24 | if (ip->ip_p != IPPROTO_TCP) 25 | return; 26 | 27 | @@ -57,34 +58,31 @@ 28 | if (tcp->th_flags & (TH_SYN|TH_FIN|TH_RST)) 29 | return; 30 | 31 | - libnet_build_ip(TCP_H, 0, 0, 0, 64, IPPROTO_TCP, 32 | - ip->ip_dst.s_addr, ip->ip_src.s_addr, 33 | - NULL, 0, buf); 34 | - 35 | - libnet_build_tcp(ntohs(tcp->th_dport), ntohs(tcp->th_sport), 36 | - 0, 0, TH_RST, 0, 0, NULL, 0, buf + IP_H); 37 | - 38 | seq = ntohl(tcp->th_ack); 39 | win = ntohs(tcp->th_win); 40 | 41 | snprintf(ctext, sizeof(ctext), "%s:%d > %s:%d:", 42 | - libnet_host_lookup(ip->ip_src.s_addr, 0), 43 | + libnet_addr2name4(ip->ip_src.s_addr, LIBNET_DONT_RESOLVE), 44 | ntohs(tcp->th_sport), 45 | - libnet_host_lookup(ip->ip_dst.s_addr, 0), 46 | + libnet_addr2name4(ip->ip_dst.s_addr, LIBNET_DONT_RESOLVE), 47 | ntohs(tcp->th_dport)); 48 | 49 | - ip = (struct libnet_ip_hdr *)buf; 50 | - tcp = (struct libnet_tcp_hdr *)(ip + 1); 51 | - 52 | for (i = 0; i < Opt_severity; i++) { 53 | - ip->ip_id = libnet_get_prand(PRu16); 54 | seq += (i * win); 55 | - tcp->th_seq = htonl(seq); 56 | 57 | - libnet_do_checksum(buf, IPPROTO_TCP, TCP_H); 58 | + libnet_clear_packet(l); 59 | + 60 | + libnet_build_tcp(ntohs(tcp->th_dport), ntohs(tcp->th_sport), 61 | + seq, 0, TH_RST, 0, 0, 0, LIBNET_TCP_H, 62 | + NULL, 0, l, 0); 63 | + 64 | + libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_TCP_H, 0, 65 | + libnet_get_prand(LIBNET_PRu16), 0, 64, 66 | + IPPROTO_TCP, 0, ip->ip_dst.s_addr, 67 | + ip->ip_src.s_addr, NULL, 0, l, 0); 68 | 69 | - if (libnet_write_ip(*sock, buf, sizeof(buf)) < 0) 70 | - warn("write_ip"); 71 | + if (libnet_write(l) < 0) 72 | + warn("write"); 73 | 74 | fprintf(stderr, "%s R %lu:%lu(0) win 0\n", ctext, seq, seq); 75 | } 76 | @@ -95,8 +93,10 @@ 77 | { 78 | extern char *optarg; 79 | extern int optind; 80 | - int c, sock; 81 | + int c; 82 | char *p, *intf, *filter, ebuf[PCAP_ERRBUF_SIZE]; 83 | + char libnet_ebuf[LIBNET_ERRBUF_SIZE]; 84 | + libnet_t *l; 85 | pcap_t *pd; 86 | 87 | intf = NULL; 88 | @@ -136,14 +136,14 @@ 89 | if ((pcap_off = pcap_dloff(pd)) < 0) 90 | errx(1, "couldn't determine link layer offset"); 91 | 92 | - if ((sock = libnet_open_raw_sock(IPPROTO_RAW)) == -1) 93 | + if ((l = libnet_init(LIBNET_RAW4, intf, libnet_ebuf)) == NULL) 94 | errx(1, "couldn't initialize sending"); 95 | 96 | - libnet_seed_prand(); 97 | + libnet_seed_prand(l); 98 | 99 | warnx("listening on %s [%s]", intf, filter); 100 | 101 | - pcap_loop(pd, -1, tcp_kill_cb, (u_char *)&sock); 102 | + pcap_loop(pd, -1, tcp_kill_cb, (u_char *)l); 103 | 104 | /* NOTREACHED */ 105 | 106 | -------------------------------------------------------------------------------- /pcaputil.c: -------------------------------------------------------------------------------- 1 | /* 2 | * pcaputil.c 3 | * 4 | * Copyright (c) 2000 Dug Song 5 | * 6 | * $Id: pcaputil.c,v 1.2 2001/03/15 08:33:04 dugsong Exp $ 7 | */ 8 | 9 | #include 10 | #include 11 | #include 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #ifdef BSD 19 | #include 20 | #endif 21 | 22 | #include "pcaputil.h" 23 | 24 | #ifdef BSD 25 | static int 26 | bpf_immediate(int fd, int on) 27 | { 28 | return (ioctl(fd, BIOCIMMEDIATE, &on)); 29 | } 30 | #endif 31 | 32 | int 33 | pcap_dloff(pcap_t *pd) 34 | { 35 | int offset = -1; 36 | 37 | switch (pcap_datalink(pd)) { 38 | case DLT_EN10MB: 39 | offset = 14; 40 | break; 41 | case DLT_IEEE802: 42 | offset = 22; 43 | break; 44 | case DLT_FDDI: 45 | offset = 21; 46 | break; 47 | #ifdef DLT_LOOP 48 | case DLT_LOOP: 49 | #endif 50 | case DLT_NULL: 51 | offset = 4; 52 | break; 53 | default: 54 | warnx("unsupported datalink type"); 55 | break; 56 | } 57 | return (offset); 58 | } 59 | 60 | pcap_t * 61 | pcap_init(char *intf, char *filter, int snaplen) 62 | { 63 | pcap_t *pd; 64 | u_int net, mask; 65 | struct bpf_program fcode; 66 | char ebuf[PCAP_ERRBUF_SIZE]; 67 | 68 | if (intf == NULL && (intf = pcap_lookupdev(ebuf)) == NULL) { 69 | warnx("%s", ebuf); 70 | return (NULL); 71 | } 72 | if ((pd = pcap_open_live(intf, snaplen, 1, 512, ebuf)) == NULL) { 73 | warnx("%s", ebuf); 74 | return (NULL); 75 | } 76 | if (pcap_lookupnet(intf, &net, &mask, ebuf) == -1) { 77 | warnx("%s", ebuf); 78 | return (NULL); 79 | } 80 | if (pcap_compile(pd, &fcode, filter, 1, mask) < 0) { 81 | pcap_perror(pd, "pcap_compile"); 82 | return (NULL); 83 | } 84 | if (pcap_setfilter(pd, &fcode) == -1) { 85 | pcap_perror(pd, "pcap_compile"); 86 | return (NULL); 87 | } 88 | #ifdef BSD 89 | if (bpf_immediate(pd->fd, 1) < 0) { 90 | perror("ioctl"); 91 | return (NULL); 92 | } 93 | #endif 94 | return (pd); 95 | } 96 | 97 | /* from tcpdump util.c. */ 98 | char * 99 | copy_argv(char **argv) 100 | { 101 | char **p, *buf, *src, *dst; 102 | u_int len = 0; 103 | 104 | p = argv; 105 | if (*p == 0) 106 | return (0); 107 | 108 | while (*p) 109 | len += strlen(*p++) + 1; 110 | 111 | if ((buf = (char *)malloc(len)) == NULL) 112 | err(1, "copy_argv: malloc"); 113 | 114 | p = argv; 115 | dst = buf; 116 | 117 | while ((src = *p++) != NULL) { 118 | while ((*dst++ = *src++) != '\0') 119 | ; 120 | dst[-1] = ' '; 121 | } 122 | dst[-1] = '\0'; 123 | 124 | return (buf); 125 | } 126 | -------------------------------------------------------------------------------- /pcaputil.h: -------------------------------------------------------------------------------- 1 | /* 2 | * pcaputil.h 3 | * 4 | * pcap utility routines. 5 | * 6 | * Copyright (c) 2000 Dug Song 7 | * 8 | * $Id: pcaputil.h,v 1.2 2001/03/15 08:33:06 dugsong Exp $ 9 | */ 10 | 11 | #ifndef PCAPUTIL_H 12 | #define PCAPUTIL_H 13 | 14 | pcap_t *pcap_init(char *intf, char *filter, int snaplen); 15 | 16 | int pcap_dloff(pcap_t *pd); 17 | 18 | char *copy_argv(char **argv); 19 | 20 | #endif /* PCAPUTIL_H */ 21 | -------------------------------------------------------------------------------- /tcpkill.8: -------------------------------------------------------------------------------- 1 | .TH TCPKILL 8 2 | .ad 3 | .fi 4 | .SH NAME 5 | tcpkill 6 | \- 7 | kill TCP connections on a LAN 8 | .SH SYNOPSIS 9 | .na 10 | .nf 11 | .fi 12 | \fBtcpkill\fR [\fB-i \fIinterface\fR] [\fB-1\fR...\fB9\fR] \fIexpression\fR 13 | .SH DESCRIPTION 14 | .ad 15 | .fi 16 | \fBtcpkill\fR kills specified in-progress TCP connections (useful for 17 | libnids-based applications which require a full TCP 3-whs for TCB 18 | creation). 19 | .SH OPTIONS 20 | .IP "\fB-i \fIinterface\fR" 21 | Specify the interface to listen on. 22 | .IP \fB-1\fR...\fB9\fR 23 | Specify the degree of brute force to use in killing a connection. Fast 24 | connections may require a higher number in order to land a RST in the 25 | moving receive window. Default is 3. 26 | .IP \fIexpression\fR 27 | Specify a tcpdump(8) filter expression to select the connections to 28 | kill. 29 | .SH "SEE ALSO" 30 | dsniff(8), tcpnice(8) 31 | .SH AUTHOR 32 | .na 33 | .nf 34 | Dug Song 35 | -------------------------------------------------------------------------------- /tcpkill.c: -------------------------------------------------------------------------------- 1 | /* 2 | * tcpkill.c 3 | * 4 | * Kill TCP connections already in progress. 5 | * 6 | * Copyright (c) 2000 Dug Song 7 | * 8 | * $Id: tcpkill.c,v 1.17 2001/03/17 08:10:43 dugsong Exp $ 9 | */ 10 | 11 | #include 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #include "pcaputil.h" 22 | #include "version.h" 23 | 24 | #define DEFAULT_SEVERITY 3 25 | 26 | int Opt_severity = DEFAULT_SEVERITY; 27 | int pcap_off; 28 | pcap_t *pd; 29 | int Opt_max_kill = 0; 30 | int kill_counter = 0; 31 | 32 | static void 33 | usage(void) 34 | { 35 | fprintf(stderr, "Version: " VERSION "\n" 36 | "Usage: tcpkill [-i interface] [-m max kills] [-1..9] expression\n"); 37 | exit(1); 38 | } 39 | 40 | static void 41 | tcp_kill_cb(u_char *user, const struct pcap_pkthdr *pcap, const u_char *pkt) 42 | { 43 | struct libnet_ipv4_hdr *ip; 44 | struct libnet_tcp_hdr *tcp; 45 | char ctext[64]; 46 | u_int32_t seq, win; 47 | int i, len; 48 | libnet_t *l; 49 | 50 | l = (libnet_t *)user; 51 | pkt += pcap_off; 52 | len = pcap->caplen - pcap_off; 53 | 54 | ip = (struct libnet_ipv4_hdr *)pkt; 55 | if (ip->ip_p != IPPROTO_TCP) 56 | return; 57 | 58 | tcp = (struct libnet_tcp_hdr *)(pkt + (ip->ip_hl << 2)); 59 | if (tcp->th_flags & (TH_SYN|TH_FIN|TH_RST)) 60 | return; 61 | 62 | seq = ntohl(tcp->th_ack); 63 | win = ntohs(tcp->th_win); 64 | 65 | snprintf(ctext, sizeof(ctext), "%s:%d > %s:%d:", 66 | libnet_addr2name4(ip->ip_src.s_addr, LIBNET_DONT_RESOLVE), 67 | ntohs(tcp->th_sport), 68 | libnet_addr2name4(ip->ip_dst.s_addr, LIBNET_DONT_RESOLVE), 69 | ntohs(tcp->th_dport)); 70 | 71 | for (i = 0; i < Opt_severity; i++) { 72 | seq += (i * win); 73 | 74 | libnet_clear_packet(l); 75 | 76 | libnet_build_tcp(ntohs(tcp->th_dport), ntohs(tcp->th_sport), 77 | seq, 0, TH_RST, 0, 0, 0, LIBNET_TCP_H, 78 | NULL, 0, l, 0); 79 | 80 | libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_TCP_H, 0, 81 | libnet_get_prand(LIBNET_PRu16), 0, 64, 82 | IPPROTO_TCP, 0, ip->ip_dst.s_addr, 83 | ip->ip_src.s_addr, NULL, 0, l, 0); 84 | 85 | if (libnet_write(l) < 0) 86 | warn("write"); 87 | 88 | fprintf(stderr, "%s R %lu:%lu(0) win 0\n", 89 | ctext, 90 | (unsigned long) seq, 91 | (unsigned long) seq); 92 | } 93 | 94 | ++kill_counter; 95 | if (Opt_max_kill && kill_counter >= Opt_max_kill) { 96 | pcap_breakloop(pd); 97 | } 98 | } 99 | 100 | int 101 | main(int argc, char *argv[]) 102 | { 103 | extern char *optarg; 104 | extern int optind; 105 | int c; 106 | char *p, *intf, *filter, ebuf[PCAP_ERRBUF_SIZE]; 107 | char libnet_ebuf[LIBNET_ERRBUF_SIZE]; 108 | libnet_t *l; 109 | 110 | intf = NULL; 111 | 112 | while ((c = getopt(argc, argv, "i:m:123456789h?V")) != -1) { 113 | switch (c) { 114 | case 'i': 115 | intf = optarg; 116 | break; 117 | case 'm': 118 | Opt_max_kill = atoi(optarg); 119 | break; 120 | case '0': case '1': case '2': case '3': case '4': 121 | case '5': case '6': case '7': case '8': case '9': 122 | p = argv[optind - 1]; 123 | if (p[0] == '-' && p[1] == c && p[2] == '\0') 124 | Opt_severity = atoi(++p); 125 | else 126 | Opt_severity = atoi(argv[optind] + 1); 127 | break; 128 | default: 129 | usage(); 130 | break; 131 | } 132 | } 133 | if (intf == NULL && (intf = pcap_lookupdev(ebuf)) == NULL) 134 | errx(1, "%s", ebuf); 135 | 136 | argc -= optind; 137 | argv += optind; 138 | 139 | if (argc == 0) 140 | usage(); 141 | 142 | filter = copy_argv(argv); 143 | 144 | if ((pd = pcap_init(intf, filter, 64)) == NULL) 145 | errx(1, "couldn't initialize sniffing"); 146 | 147 | if ((pcap_off = pcap_dloff(pd)) < 0) 148 | errx(1, "couldn't determine link layer offset"); 149 | 150 | if ((l = libnet_init(LIBNET_RAW4, intf, libnet_ebuf)) == NULL) 151 | errx(1, "couldn't initialize sending"); 152 | 153 | libnet_seed_prand(l); 154 | 155 | warnx("listening on %s [%s]", intf, filter); 156 | 157 | pcap_loop(pd, -1, tcp_kill_cb, (u_char *)l); 158 | 159 | /* NOTREACHED */ 160 | 161 | exit(0); 162 | } 163 | -------------------------------------------------------------------------------- /version.h: -------------------------------------------------------------------------------- 1 | #define VERSION "2.4" 2 | --------------------------------------------------------------------------------