diff options
Diffstat (limited to 'pptpd-1.3.3/bcrelay.c')
| -rw-r--r-- | pptpd-1.3.3/bcrelay.c | 1014 |
1 files changed, 1014 insertions, 0 deletions
diff --git a/pptpd-1.3.3/bcrelay.c b/pptpd-1.3.3/bcrelay.c new file mode 100644 index 0000000..b345795 --- /dev/null +++ b/pptpd-1.3.3/bcrelay.c @@ -0,0 +1,1014 @@ +// A broadcast packet repeater. This packet repeater (currently designed for +// udp packets) will listen for broadcast packets. +// When it receives the packets, it will then re-broadcast the packet. +// +// Written by TheyCallMeLuc(at)yahoo.com.au +// I accept no responsiblity for the function of this program if you +// choose to use it. +// Modified for Poptop by Richard de Vroede <r.devroede@linvision.com> +// Ditto on the no responsibility. +// +// Rewritten by Norbert van Bolhuis <norbert@vanbolhuis.demon.nl> bcrelay (v1.0+) +// now supports/does: +// 1) Relaying from PPP (VPN tunnel) interfaces, hereby creating a virtual +// LAN (w.r.t. UDP broadcasts) for VPN clients and ethernet PCs +// belonging/matching the subnet portion of the VPN IP addresses. +// So now broadcasting to/from all systems of the VPN has been implemented. +// Note that bcrelay v0.5 only relayed from LAN to VPN clients. +// It doesn't matter whether the systems on the VPN are on the LAN of the +// VPN server or have a VPN/PPTP connection (over the internet) to the VPN +// server. Broadcasts will always be relayed to/from all given interfaces. And +// as long as the subnet portion of the IP addresses of the systems on the VPN +// matches, the VPN server will be able to route properly. This means all +// networking applications/games that rely on a UDP broadcast from one or +// more PPP (VPN tunnel) interfaces will now see eachother and work over +// the VPN. +// Note that it depends on the networking application/game and whoever +// acts as application/game server/host who is sending (UPD) broadcasts +// and who is listening. +// 2) UDP broadcasts received on a PPP interface (VPN tunnel) sometimes +// don't carry the VPN IP address which pptpd provisioned. I've seen +// this happening on a WinXP SP1 box, especially when the application +// responsible for the UDP broadcasts isn't aware of the PPP interface. +// In this case it just uses the LAN IP src address for the IP src +// address of the inner (GRE encapsulated) IP packet. This breaks +// the "virtual LAN" and therefore bcrelay, as of this version, changes +// the src IP address to the VPN IP address (which pptpd provisioned) +// before relaying. +// 3) To avoid a UDP broadcast loop, bcrelay changes the IP TTL and the +// UDP checksum (to 1 and 0 respectively) of the UDP broadcasts it relays. +// No relaying will be done for UDP broadcasts with IP TTL=1 and UDP +// checksum=0. Could also (mis)use IP identification for this, but IP TTL +// and UDP chksum combination is expected to work fine. +// 4) bcrelay v0.5 forgot to update IP/UDP checksum when it changed the +// dest. IP address (e.g. from 192.168.1.255 to 255.255.255.255). +// Of course as of this version bcrelay always updates the IP/UDP +// checksum since the IP TTL and src IP address will change also. +// 5) Enhanced the (syslog) debugging capabilities. By default bcrelay will +// show what it is doing. Bcrelay will syslog the IP interfaces it tries +// to read/relay UDP broadcasts from/to. These interfaces are called +// the 'active interfaces', bcrelay will syslog the initial set of active +// interfaces and whenever the set changes. Currently there is no difference +// between an incoming interface (given with -i) and an outgoing interface +// (given with -o), so bcrelay won't show this attribute. Also, bcrelay will +// syslog a successfully relayed UDP broadcast, including the UDP port numbers, +// the incoming interface and the interface(s) to which it was successfully +// relayed. The (new) -n option allows to suppress syslog tracing. +// If -n is given, bcrelay shows/syslogs nothing, except fatal error +// messages. +// +// This software is completely free. You can use and/or modify this +// software to your hearts content. You are free to redistribute it as +// long as it is accompanied with the source and my credit is included. + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#ifdef __linux__ +#define _GNU_SOURCE 1 /* strdup() prototype, broken arpa/inet.h */ +#endif + +#ifdef __svr4__ +#define __EXTENSIONS__ 1 /* strdup() prototype */ +#endif + +#ifdef __sgi__ +#define _XOPEN_SOURCE 500 /* strdup() prototype */ +#endif + +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <netdb.h> +#include <unistd.h> +#include <string.h> +#include <libgen.h> +#include <time.h> +#include <sys/time.h> +#include <regex.h> +#include <net/if.h> +#include <sys/ioctl.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <netinet/in.h> +#include <netpacket/packet.h> +#include <net/ethernet.h> +#include <netinet/ip.h> +#include <netinet/udp.h> +#include <netinet/tcp.h> +#include <dirent.h> + +#include "defaults.h" +#include "our_syslog.h" +#include "our_getopt.h" + +//#define VERSION "1.0" + +/* uncomment if you compile this without poptop's configure script */ +//#define HAVE_FORK + +/* + * Value-return macros to fields in the IP PDU header + */ +#define IP_IPPDU_IHL(ippdu) (*(unsigned char *)(ippdu) & 0x0F) +#define IP_IPPDU_PROTO(ippdu) (*((unsigned char *)(ippdu) + 9) & 0xFF) + +/* + * Pointer macros to fields in the IP PDU header + */ +#define IP_IPPDU_CHECKSUM_MSB_PTR(ippdu) ((unsigned char *)(ippdu) + 10 ) +#define IP_IPPDU_CHECKSUM_LSB_PTR(ippdu) ((unsigned char *)(ippdu) + 11 ) + +/* + * Pointer macros to fields in the UDP PDU header + */ +#define IP_UDPPDU_CHECKSUM_MSB_PTR(udppdu) ((unsigned char *)(udppdu) + 6 ) +#define IP_UDPPDU_CHECKSUM_LSB_PTR(udppdu) ((unsigned char *)(udppdu) + 7 ) + +#define MAXIF 255 // Maximum interfaces to use +#define MAX_SELECT_WAIT 3 // Maximum time (in secs) to wait for input on the socket/interfaces + // A time-out triggers the discovery of new interfaces. +#define MAX_NODISCOVER_IFS 12 // Maximum time (in secs) to elaps before a discovery of new + // interfaces is triggered. Only when a packet keeps coming in + // (this prevents a select time-out) a variable initialized with + // this #define becomes 0 and a rediscovery of the interfaces is + // triggered. +#define MAX_IFLOGTOSTR 16 + +/* Local function prototypes */ +static void showusage(char *prog); +static void showversion(); +#ifndef HAVE_DAEMON +static void my_daemon(int argc, char **argv); +#endif +static void mainloop(int argc, char **argv); + +struct packet { + struct iphdr ip; + struct udphdr udp; + char data[ETHERMTU]; +}; + + +/* + * struct that keeps track of the interfaces of the system + * selected upon usage by bcrelay (with -i and -o option). + * An array of this struct is returned by discoverActiveInterfaces. + * This array is reset (filled from scratch) each time + * discoverActiveInterfaces is called. + */ +struct iflist { +//Fix 3mar2003 + //char index; + int index; + u_int32_t bcast; + char ifname[16+1]; + unsigned long ifaddr; + unsigned long ifdstaddr; + unsigned long flags1; +}; + +#define IFLIST_FLAGS1_IF_IS_ETH 0x00000001 +#define IFLIST_FLAGS1_IF_IS_PPP 0x00000002 +#define IFLIST_FLAGS1_IF_IS_UNKNOWN 0x00000004 +#define IFLIST_FLAGS1_CHANGED_INNER_SADDR 0x00010000 + + +/* + * struct that keeps track of the socket fd's for every interface + * that is in use (and thus present in iflist). + * Two permanent arrays of this struct are used, one for the + * previous/old list and one for the current list. + */ +struct ifsnr { + int sock_nr; + int ifindex; +}; + +static void copy_ifsnr(struct ifsnr *from, struct ifsnr *to); +static int find_sock_nr(struct ifsnr *l, int ifidx); +struct iflist *discoverActiveInterfaces(int s); +void ip_update_checksum(unsigned char *ippdu); +static char *IpProtToString( unsigned char prot ); +static char *iflistToString( struct iflist *ifp ); +static char *iflistLogIToString( struct iflist *ifp, int idx, struct ifsnr *ifnr ); +static char *iflistLogRToString( struct iflist *ifp, int idx, struct ifsnr *ifnr ); +static void bind_to_iface(int fd, int ifindex); + +/* + * This global variable determines whether NVBCR_PRINTF actually + * displays something. While developping v1.0, NVBCR_PRINTF were + * printf and a lot of tracing/logging/debugging was done with these. + * Of course, by default these 'info' messages have been turned off + * now. Enable by setting variable to 1. Note that output will only + * appear in non-daemon mode (see also NVBCR_PRINTF). + */ +static int do_org_info_printfs = 0; + +static int vnologging = 0; +static int vdaemon = 0; + +#define NVBCR_PRINTF( args ) \ + if ((vdaemon == 0) && (do_org_info_printfs == 1)) printf args + +static char interfaces[32]; +static char log_interfaces[MAX_IFLOGTOSTR*MAXIF]; +static char log_relayed[(MAX_IFLOGTOSTR-1)*MAXIF+81]; +static char *ipsec = ""; + +static void showusage(char *prog) +{ + printf("\nBCrelay v%s\n\n", VERSION); + printf("A broadcast packet repeater. This packet repeater (currently designed for udp packets) will listen\n"); + printf(" for broadcast packets. When it receives the packets, it will then re-broadcast the packet.\n\n"); + printf("Usage: %s [options], where options are:\n\n", prog); + printf(" [-d] [--daemon] Run as daemon.\n"); + printf(" [-h] [--help] Displays this help message.\n"); + printf(" [-i] [--incoming <ifin>] Defines from which interface broadcasts will be relayed.\n"); + printf(" [-n] [--nolog] No logging/tracing to /var/log/messages.\n"); + printf(" [-o] [--outgoing <ifout>] Defines to which interface broadcasts will be relayed.\n"); + printf(" [-s] [--ipsec <arg>] Defines an ipsec tunnel to be relayed to.\n"); + printf(" Since ipsec tunnels terminate on the same interface, we need to define the broadcast\n"); + printf(" address of the other end-point of the tunnel. This is done as ipsec0:x.x.x.255\n"); + printf(" [-v] [--version] Displays the BCrelay version number.\n"); + printf("\nLog messages and debugging go to syslog as DAEMON.\n\n"); + printf("\nInterfaces can be specified as regexpressions, ie. ppp[0-9]+\n\n"); +} + +static void showversion() +{ + printf("BCrelay v%s\n", VERSION); +} + +#ifndef HAVE_DAEMON +static void my_daemon(int argc, char **argv) +{ + pid_t pid; +#ifndef BCRELAY_BIN +/* Need a smart way to locate the binary -rdv */ +#define BCRELAY_BIN argv[0] +#endif +#ifndef HAVE_FORK + /* need to use vfork - eg, uClinux */ + char **new_argv; + extern char **environ; + int minusd=0; + int i; + int fdr; + + /* Strip -d option */ + new_argv = malloc((argc) * sizeof(char **)); + fdr = open("/dev/null", O_RDONLY); + new_argv[0] = BCRELAY_BIN; + for (i = 1; argv[i] != NULL; i++) { + if (fdr != 0) { dup2(fdr, 0); close(fdr); } + if ( (strcmp(argv[i],"-d")) == 0 ) { + minusd=1; + } + if (minusd) { + new_argv[i] = argv[i+1]; + } else { + new_argv[i] = argv[i]; + } + } + syslog(LOG_DEBUG, "Option parse OK, re-execing as daemon"); + fflush(stderr); + if ((pid = vfork()) == 0) { + if (setsid() < 0) { /* shouldn't fail */ + syslog(LOG_ERR, "Setsid failed!"); + _exit(1); + } + chdir("/"); + umask(0); + /* execve only returns on an error */ + execve(BCRELAY_BIN, new_argv, environ); + exit(1); + } else if (pid > 0) { + syslog(LOG_DEBUG, "Success re-execing as daemon!"); + exit(0); + } else { + syslog(LOG_ERR, "Error vforking"); + exit(1); + } +#else + pid=fork(); + if (pid<0) { syslog(LOG_ERR, "Error forking"); _exit(1); } + if (pid>0) { syslog(LOG_DEBUG, "Parent exits"); _exit(0); } + if (pid==0) { syslog(LOG_DEBUG, "Running as child"); } + /* child (daemon) continues */ + if (setsid() < 0) { /* shouldn't fail */ + syslog(LOG_ERR, "Setsid failed!"); + _exit(1); + } + chdir("/"); +#endif +} +#endif + +int main(int argc, char **argv) { + regex_t preg; + /* command line options */ + int c; + char *ifout = ""; + char *ifin = ""; + +#ifndef BCRELAY + fprintf(stderr, + "bcrelay: pptpd was compiled without support for bcrelay, exiting.\n" + " run configure --with-bcrelay, make, and install.\n"); + exit(1); +#endif + + /* open a connection to the syslog daemon */ + openlog("bcrelay", LOG_PID, PPTP_FACILITY); + + while (1) { + int option_index = 0; + + static struct option long_options[] = + { + {"nolog", 0, 0, 0}, + {"daemon", 0, 0, 0}, + {"help", 0, 0, 0}, + {"incoming", 1, 0, 0}, + {"outgoing", 1, 0, 0}, + {"ipsec", 1, 0, 0}, + {"version", 0, 0, 0}, + {0, 0, 0, 0} + }; + + c = getopt_long(argc, argv, "ndhi:o:s:v", long_options, &option_index); + if (c == -1) + break; + /* convert long options to short form */ + if (c == 0) + c = "ndhiosv"[option_index]; + switch (c) { + case 'n': + vnologging = 1; + break; + case 'd': + vdaemon = 1; + break; + case 'h': + showusage(argv[0]); + return 0; + case 'i': + ifin = strdup(optarg); + break; + case 'o': + ifout = strdup(optarg); + break; + case 's': + ipsec = strdup(optarg); + // Validate the ipsec parameters + regcomp(&preg, "ipsec[0-9]+:[0-9]+.[0-9]+.[0-9]+.255", REG_EXTENDED); + if (regexec(&preg, ipsec, 0, NULL, 0)) { + syslog(LOG_INFO,"Bad syntax: %s", ipsec); + fprintf(stderr, "\nBad syntax: %s\n", ipsec); + showusage(argv[0]); + return 0; + } else { + regfree(&preg); + break; + } + case 'v': + showversion(); + return 0; + default: + showusage(argv[0]); + return 1; + } + } + if (ifin == "") { + syslog(LOG_INFO,"Incoming interface required!"); + showusage(argv[0]); + _exit(1); + } + if (ifout == "" && ipsec == "") { + syslog(LOG_INFO,"Listen-mode or outgoing or IPsec interface required!"); + showusage(argv[0]); + _exit(1); + } else { + sprintf(interfaces,"%s|%s", ifin, ifout); + } + + // If specified, become Daemon. + if (vdaemon) { +#if HAVE_DAEMON + closelog(); + freopen("/dev/null", "r", stdin); + /* set noclose, we want stdout/stderr still attached if we can */ + daemon(0, 1); + /* returns to child only */ + /* pid will have changed */ + openlog("bcrelay", LOG_PID, PPTP_FACILITY); +#else /* !HAVE_DAEMON */ + my_daemon(argc, argv); + /* returns to child if !HAVE_FORK + * never returns if HAVE_FORK (re-execs without -d) + */ +#endif + } else { + syslog(LOG_INFO, "Running as child\n"); + } + mainloop(argc,argv); + _exit(0); +} + +static void mainloop(int argc, char **argv) +{ + socklen_t salen = sizeof(struct sockaddr_ll); + int i, s, rcg, j, no_discifs_cntr, ifs_change; + int logstr_cntr; + struct iflist *iflist = NULL; // Initialised after the 1st packet + struct sockaddr_ll sa; + struct packet *ipp_p; + char *udppdu; // FIXME: warning: pointer targets in assignment differ in signedness + fd_set sock_set; + struct timeval time_2_wait; + static struct ifsnr old_ifsnr[MAXIF+1]; // Old iflist to socket fd's mapping list + static struct ifsnr cur_ifsnr[MAXIF+1]; // Current iflist to socket fd's mapping list + unsigned char buf[1518]; + char *logstr = ""; + + no_discifs_cntr = MAX_NODISCOVER_IFS; + ifs_change = 0; + + /* + * Open general ethernet socket, only used to discover interfaces. + */ + if ((s = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL))) < 0) + syslog(LOG_INFO,"%s: Error creating socket", *argv); + + + /* + * Discover interfaces (initial set) and create a dedicated socket bound to the interface + */ + memset(old_ifsnr, -1, sizeof(old_ifsnr)); + memset(cur_ifsnr, -1, sizeof(cur_ifsnr)); + iflist = discoverActiveInterfaces(s); + for (i=0; iflist[i].index; ++i) { + if ((cur_ifsnr[i].sock_nr = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL))) < 0) { + syslog(LOG_ERR, "mainloop: Error, socket error! (rv=%d, errno=%d)", cur_ifsnr[i].sock_nr, errno); + exit(1); + } + bind_to_iface(cur_ifsnr[i].sock_nr, iflist[i].index); + cur_ifsnr[i].ifindex = iflist[i].index; + } + NVBCR_PRINTF(("Displaying INITIAL active interfaces..\n")); + if (vnologging == 0) { + logstr = log_interfaces; + logstr_cntr = sprintf(logstr, "Initial active interfaces: "); + logstr += logstr_cntr; + } + for (i = 0; iflist[i].index; i++) + { + NVBCR_PRINTF(("\t\tactive interface number: %d, if=(%s), sock_nr=%d\n", i, iflistToString(&(iflist[i])), cur_ifsnr[i].sock_nr)); + if (vnologging == 0) { + logstr_cntr = sprintf(logstr, "%s ", iflistLogIToString(&(iflist[i]), i, &(cur_ifsnr[i]))); + logstr += logstr_cntr; + } + } + if (vnologging == 0) syslog(LOG_INFO, "%s", log_interfaces); + + // Main loop + while (1) + { + + /* + * Check all (interface) sockets for incoming packets + */ + FD_ZERO(&sock_set); + for (i=0; iflist[i].index; ++i) + { + if (cur_ifsnr[i].sock_nr >= 0) { + FD_SET(cur_ifsnr[i].sock_nr, &sock_set); + } + } + + /* + * Don't wait more than MAX_SELECT_WAIT seconds + */ + time_2_wait.tv_sec = MAX_SELECT_WAIT; + time_2_wait.tv_usec = 0L; + + /* select on sockets */ + rcg = select(MAXIF, &sock_set, (fd_set *) NULL,(fd_set *) NULL, &time_2_wait); + + if (rcg < 0) + { + syslog(LOG_ERR, "Error, select error! (rv=%d, errno=%d)", rcg, errno); + exit(1); + } + + if (rcg == 0) + { + /* TimeOut, rediscover interfaces */ + NVBCR_PRINTF(("Select timeout, rediscover interfaces\n")); + copy_ifsnr(cur_ifsnr, old_ifsnr); + memset(cur_ifsnr, -1, sizeof(cur_ifsnr)); + iflist = discoverActiveInterfaces(s); + /* + * Build new cur_ifsnr list. + * Make iflist[i] correspond with cur_ifsnr[i], so iflist[i].index == cur_ifsnr[i].ifindex + * The old list (old_ifsnr) is used to compare. + */ + for (i=0; iflist[i].index; ++i) { + /* check to see if it is a NEW interface */ + int fsnr = find_sock_nr(old_ifsnr, iflist[i].index); + if (fsnr == -1) { + /* found new interface, open dedicated socket and bind it to the interface */ + if ((cur_ifsnr[i].sock_nr = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL))) < 0) { + syslog(LOG_ERR, "mainloop: Error, socket error! (rv=%d, errno=%d)", cur_ifsnr[i].sock_nr, errno); + exit(1); + } + bind_to_iface(cur_ifsnr[i].sock_nr, iflist[i].index); + ifs_change = 1; + } + else + { + /* + * not a new interface, socket already openen, interface already + * bound. Update cur_ifsnr. + */ + cur_ifsnr[i].sock_nr = fsnr; + } + cur_ifsnr[i].ifindex = iflist[i].index; + } + /* Close disappeared interfaces */ + for (i=0; i<MAXIF; ++i) + { + if ((old_ifsnr[i].sock_nr != -1) && (old_ifsnr[i].ifindex != -1) && + (find_sock_nr(cur_ifsnr, old_ifsnr[i].ifindex) == -1)) { + NVBCR_PRINTF(("Closing an interface (it disappeared), namely: (s_nr=%d, ifidx=%d)\n", old_ifsnr[i].sock_nr, old_ifsnr[i].ifindex)); + close(old_ifsnr[i].sock_nr); + old_ifsnr[i].sock_nr = -1; + old_ifsnr[i].ifindex = -1; + ifs_change = 1; + } + } + if (ifs_change == 1) + { + NVBCR_PRINTF(("Active interface set changed --> displaying current active interfaces..\n")); + if (vnologging == 0) { + logstr = log_interfaces; + logstr_cntr = sprintf(logstr, "Active interface set changed to: "); + logstr += logstr_cntr; + } + for (i = 0; iflist[i].index; i++) + { + NVBCR_PRINTF(("\t\tactive interface number: %d, if=(%s), sock_nr=%d\n", i, iflistToString(&(iflist[i])), cur_ifsnr[i].sock_nr)); + if (vnologging == 0) { + logstr_cntr = sprintf(logstr, "%s ", iflistLogIToString(&(iflist[i]), i, &(cur_ifsnr[i]))); + logstr += logstr_cntr; + } + } + if (vnologging == 0) syslog(LOG_INFO, "%s", log_interfaces); + ifs_change = 0; + } + continue; + } + + if (rcg > 0) + { + /* rcg interfaces have pending input */ + for (i=0; ((iflist[i].index != 0) && (rcg > 0)); ++i) + { + if ((cur_ifsnr[i].sock_nr != -1) && (FD_ISSET(cur_ifsnr[i].sock_nr,&sock_set))) + { + /* Valid socket number and pending input, let's read */ + int rlen = read(cur_ifsnr[i].sock_nr, buf, sizeof(buf)); + ipp_p = (struct packet *)&(buf[0]); + NVBCR_PRINTF(("IP_Packet=(tot_len=%d, id=%02x%02x, ttl=%d, prot=%s, src_ip=%d.%d.%d.%d, dst_ip=%d.%d.%d.%d) (on if: %d/%d) ", ntohs(ipp_p->ip.tot_len), (ntohs(ipp_p->ip.id))>>8, (ntohs(ipp_p->ip.id))&0x00ff, ipp_p->ip.ttl, IpProtToString(ipp_p->ip.protocol), (ntohl(ipp_p->ip.saddr))>>24, ((ntohl(ipp_p->ip.saddr))&0x00ff0000)>>16, ((ntohl(ipp_p->ip.saddr))&0x0000ff00)>>8, (ntohl(ipp_p->ip.saddr))&0x000000ff, (ntohl(ipp_p->ip.daddr))>>24, ((ntohl(ipp_p->ip.daddr))&0x00ff0000)>>16, ((ntohl(ipp_p->ip.daddr))&0x0000ff00)>>8, (ntohl(ipp_p->ip.daddr))&0x000000ff, i, iflist[i].index)); + rcg -= 1; + + if ( (ipp_p->ip.protocol == IPPROTO_UDP) && + (((ntohl(ipp_p->ip.daddr)) & 0x000000ff) == 0x000000ff) && + (ipp_p->ip.ttl != 1) && + (!((*IP_UDPPDU_CHECKSUM_MSB_PTR((unsigned char *)ipp_p+(4*ipp_p->ip.ihl)) == 0) && + (*IP_UDPPDU_CHECKSUM_LSB_PTR((unsigned char *)ipp_p+(4*ipp_p->ip.ihl)) == 0))) ) + { + int nrsent; + int ifindex_to_exclude = iflist[i].index; + + NVBCR_PRINTF(("is an UDP BROADCAST (dstPort=%d, srcPort=%d) (with TTL!=1 and UDP_CHKSUM!=0)\n\n", + ntohs(ipp_p->udp.dest), ntohs(ipp_p->udp.source))); + if (vnologging == 0) { + logstr = log_relayed; + logstr_cntr = sprintf(logstr, "UDP_BroadCast(sp=%d,dp=%d) from: %s relayed to: ", ntohs(ipp_p->udp.source), + ntohs(ipp_p->udp.dest), iflistLogRToString(&(iflist[i]), i, &(cur_ifsnr[i]))); + logstr += logstr_cntr; + } + + /* going to relay a broadcast packet on all the other interfaces */ + for (j=0; iflist[j].index; ++j) + { + int prepare_ipp = 0; // Changing the incoming UDP broadcast needs to be done once + + if (iflist[j].index != ifindex_to_exclude) + { + NVBCR_PRINTF(("Going to sent UDP Broadcast on interface: %s, sock_nr=%d\n", iflistToString(&(iflist[j])), cur_ifsnr[j].sock_nr)); + + memset(&sa, 0, salen); + + sa.sll_family = AF_PACKET; + sa.sll_ifindex = iflist[j].index; /* Must be the SIOCGIFINDEX number */ + // Set the outgoing hardware address to 1's. True Broadcast + sa.sll_addr[0] = sa.sll_addr[1] = sa.sll_addr[2] = sa.sll_addr[3] = 0xff; + sa.sll_addr[4] = sa.sll_addr[5] = sa.sll_addr[6] = sa.sll_addr[7] = 0xff; + sa.sll_halen = 6; + + /* + * htons(ETH_P_IP) is necessary otherwise sendto will + * succeed but no packet is actually sent on the wire (this + * was the case for PPP interfaces, for ETH interfaces an unknown + * LAN frame is sent if htons(ETH_P_IP) is not set as protocol). + */ + sa.sll_protocol = htons(ETH_P_IP); /* ETH_P_PPP_MP */ + + if (prepare_ipp == 0) { + // change TimeToLive to 1, This is to avoid loops, bcrelay will *NOT* relay + // anything with TTL==1. + ipp_p->ip.ttl = 1; + + // The CRC gets broken here when sending over ipsec tunnels but that + // should not matter as we reassemble the packet at the other end. + ipp_p->ip.daddr = iflist[j].bcast; + + // check IP srcAddr (on some winXP boxes it is found to be + // different from the configured ppp address). + // Only do this for PPP interfaces. + if ((iflist[i].flags1 & IFLIST_FLAGS1_IF_IS_PPP) && + (ntohl(ipp_p->ip.saddr) != iflist[i].ifdstaddr)) + { + ipp_p->ip.saddr = htonl(iflist[i].ifdstaddr); + iflist[i].flags1 |= IFLIST_FLAGS1_CHANGED_INNER_SADDR; + } + + // Update IP checkSum (TTL and src/dest IP Address might have changed) + ip_update_checksum((unsigned char *)ipp_p); + /* Disable upper layer checksum */ + udppdu = (unsigned char *)ipp_p + (4 * ipp_p->ip.ihl); + *IP_UDPPDU_CHECKSUM_MSB_PTR(udppdu) = (unsigned char)0; + *IP_UDPPDU_CHECKSUM_LSB_PTR(udppdu) = (unsigned char)0; + + prepare_ipp = 1; + } + + /* + * The beauty of sending IP packets on a PACKET socket of type SOCK_DGRAM is that + * there is no need to concern about the physical/link layer header because it is + * filled in automatically (based on the contents of sa). + */ + if ((nrsent = sendto(cur_ifsnr[j].sock_nr, ipp_p, rlen, MSG_DONTWAIT|MSG_TRYHARD, (struct sockaddr *)&sa, salen)) < 0) + { + if (errno == ENETDOWN) { + syslog(LOG_NOTICE, "ignored ENETDOWN from sendto(), a network interface was going down?"); + } else if (errno == ENXIO) { + syslog(LOG_NOTICE, "ignored ENXIO from sendto(), a network interface went down?"); + } else if (errno == ENOBUFS) { + syslog(LOG_NOTICE, "ignored ENOBUFS from sendto(), temporary shortage of buffer memory"); + } else { + syslog(LOG_ERR, "mainloop: Error, sendto failed! (rv=%d, errno=%d)", nrsent, errno); + exit(1); + } + } + NVBCR_PRINTF(("Successfully relayed %d bytes \n", nrsent)); + if (vnologging == 0) { + logstr_cntr = sprintf(logstr, "%s ", iflistLogRToString(&(iflist[j]), j, &(cur_ifsnr[j]))); + logstr += logstr_cntr; + } + } + } + if (vnologging == 0) syslog(LOG_INFO, "%s", log_relayed); + } else { + NVBCR_PRINTF(("is NOT an UDP BROADCAST (with TTL!=1 and UDP_CHKSUM!=0)\n\n")); + } + } + } + /* + * Don't forget to discover new interfaces if we keep getting + * incoming packets (on an already discovered interface). + */ + if (no_discifs_cntr == 0) + { + no_discifs_cntr = MAX_NODISCOVER_IFS; + + /* no_discifs_cntr became 0, rediscover interfaces */ + NVBCR_PRINTF(("no_discifs_cntr became 0, rediscover interfaces\n")); + copy_ifsnr(cur_ifsnr, old_ifsnr); + memset(cur_ifsnr, -1, sizeof(cur_ifsnr)); + iflist = discoverActiveInterfaces(s); + /* + * Build new cur_ifsnr list. + * Make iflist[i] correspond with cur_ifsnr[i], so iflist[i].index == cur_ifsnr[i].ifindex + * The old list (old_ifsnr) is used to compare. + */ + for (i=0; iflist[i].index; ++i) { + /* check to see if it is a NEW interface */ + int fsnr = find_sock_nr(old_ifsnr, iflist[i].index); + if (fsnr == -1) { + /* found new interface, open dedicated socket and bind it to the interface */ + if ((cur_ifsnr[i].sock_nr = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL))) < 0) { + syslog(LOG_ERR, "mainloop: Error, socket error! (rv=%d, errno=%d)", cur_ifsnr[i].sock_nr, errno); + exit(1); + } + bind_to_iface(cur_ifsnr[i].sock_nr, iflist[i].index); + ifs_change = 1; + } + else + { + /* + * not a new interface, socket already openen, interface already + * bound. Update cur_ifsnr. + */ + cur_ifsnr[i].sock_nr = fsnr; + } + cur_ifsnr[i].ifindex = iflist[i].index; + } + /* Close disappeared interfaces */ + for (i=0; i<MAXIF; ++i) + { + if ((old_ifsnr[i].sock_nr != -1) && (old_ifsnr[i].ifindex != -1) && + (find_sock_nr(cur_ifsnr, old_ifsnr[i].ifindex) == -1)) { + NVBCR_PRINTF(("Closing an interface (it disappeared), namely: (s_nr=%d, ifidx=%d)\n", old_ifsnr[i].sock_nr, old_ifsnr[i].ifindex)); + close(old_ifsnr[i].sock_nr); + old_ifsnr[i].sock_nr = -1; + old_ifsnr[i].ifindex = -1; + ifs_change = 1; + } + } + if (ifs_change == 1) + { + NVBCR_PRINTF(("Active interface set changed --> displaying current active interfaces..\n")); + if (vnologging == 0) { + logstr = log_interfaces; + logstr_cntr = sprintf(logstr, "Active interface set changed to: "); + logstr += logstr_cntr; + } + for (i = 0; iflist[i].index; i++) + { + NVBCR_PRINTF(("\t\tactive interface number: %d, if=(%s), sock_nr=%d\n", i, iflistToString(&(iflist[i])), cur_ifsnr[i].sock_nr)); + if (vnologging == 0) { + logstr_cntr = sprintf(logstr, "%s ", iflistLogIToString(&(iflist[i]), i, &(cur_ifsnr[i]))); + logstr += logstr_cntr; + } + } + if (vnologging == 0) syslog(LOG_INFO, "%s", log_interfaces); + ifs_change = 0; + } + } + else + { + no_discifs_cntr -= MAX_SELECT_WAIT; + } + } + } +} + +// Discover active interfaces +struct iflist * +discoverActiveInterfaces(int s) { + static struct iflist iflist[MAXIF+1]; // Allow for MAXIF interfaces + static struct ifconf ifs; + int i, j, cntr = 0; + regex_t preg; + struct ifreq ifrflags, ifr; + struct sockaddr_in *sin; + + /* Reset iflist */ + memset(iflist, 0, sizeof(iflist)); + /* Reset ifs */ + memset(&ifs, 0, sizeof(ifs)); + + //regcomp(&preg, argv[1], REG_ICASE|REG_EXTENDED); + regcomp(&preg, interfaces, REG_ICASE|REG_EXTENDED); + ifs.ifc_len = MAXIF*sizeof(struct ifreq); + ifs.ifc_req = malloc(ifs.ifc_len); + ioctl(s, SIOCGIFCONF, &ifs); // Discover active interfaces + for (i = 0; i * sizeof(struct ifreq) < ifs.ifc_len && cntr < MAXIF; i++) + { + if (regexec(&preg, ifs.ifc_req[i].ifr_name, 0, NULL, 0) == 0) { + + /* + * Get interface flags and check status and type. + * Only if interface is up it will be used. + */ + memset(&ifrflags, 0, sizeof(ifrflags)); + strncpy(ifrflags.ifr_name, ifs.ifc_req[i].ifr_name, strlen(ifs.ifc_req[i].ifr_name)); + if (ioctl(s, SIOCGIFFLAGS, &ifrflags) < 0) { + syslog(LOG_ERR, "discoverActiveInterfaces: Error, SIOCGIFFLAGS Failed! (errno=%d)", errno); + exit(1); + } + + if (ifrflags.ifr_flags & IFF_UP) + { + /* + * Get interface index + */ + ioctl(s, SIOCGIFINDEX, &ifs.ifc_req[i]); +//Fix 3mar2003 + //iflist[cntr].index = (char)ifs.ifc_req[i].ifr_ifindex; + iflist[cntr].index = ifs.ifc_req[i].ifr_ifindex; + + /* + * Get interface name + */ + for (j=0; (j<sizeof(iflist[cntr].ifname) && j<strlen(ifs.ifc_req[i].ifr_ifrn.ifrn_name)); ++j) + iflist[cntr].ifname[j] = ifs.ifc_req[i].ifr_ifrn.ifrn_name[j]; + iflist[cntr].ifname[j+1] = '\0'; + + /* + * Get local IP address + */ + memset(&ifr, 0, sizeof(ifr)); + ifr.ifr_addr.sa_family = AF_INET; + (void)strncpy(ifr.ifr_name, iflist[cntr].ifname, strlen(iflist[cntr].ifname)+1); + if (ioctl(s, SIOCGIFADDR, (char *)&ifr) < 0) { + syslog(LOG_ERR, "discoverActiveInterfaces: Error, SIOCGIFADDR Failed! (errno=%d)", errno); + exit(1); + } + sin = (struct sockaddr_in *)&ifr.ifr_addr; + iflist[cntr].ifaddr = ntohl(sin->sin_addr.s_addr); + + iflist[cntr].flags1 = 0; + + if (ifrflags.ifr_flags & IFF_POINTOPOINT) { + /* + * Get remote IP address (only for PPP interfaces) + */ + memset(&ifr, 0, sizeof(ifr)); + ifr.ifr_addr.sa_family = AF_INET; + (void)strncpy(ifr.ifr_name, iflist[cntr].ifname, strlen(iflist[cntr].ifname)+1); + if (ioctl(s, SIOCGIFDSTADDR, (char *)&ifr) < 0) { + syslog(LOG_ERR, "discoverActiveInterfaces: Error, SIOCGIFDSTADDR Failed! (errno=%d)", errno); + exit(1); + } + sin = (struct sockaddr_in *)&ifr.ifr_addr; + iflist[cntr].ifdstaddr = ntohl(sin->sin_addr.s_addr); + + iflist[cntr].flags1 |= IFLIST_FLAGS1_IF_IS_PPP; + iflist[cntr].bcast = INADDR_BROADCAST; + } + else if (ifrflags.ifr_flags & IFF_BROADCAST) + { + iflist[cntr].ifdstaddr = 0; + iflist[cntr].flags1 |= IFLIST_FLAGS1_IF_IS_ETH; + iflist[cntr].bcast = INADDR_BROADCAST; + } + else + { + iflist[cntr].ifdstaddr = 0; + iflist[cntr].flags1 |= IFLIST_FLAGS1_IF_IS_UNKNOWN; + iflist[cntr].bcast = INADDR_BROADCAST; + } + + cntr++; + } + // IPSEC tunnels are a fun one. We must change the destination address + // so that it will be routed to the correct tunnel end point. + // We can define several tunnel end points for the same ipsec interface. + } else if (ipsec != "" && strncmp(ifs.ifc_req[i].ifr_name, "ipsec", 5) == 0) { + if (strncmp(ifs.ifc_req[i].ifr_name, ipsec, 6) == 0) { + struct hostent *hp = gethostbyname(ipsec+7); + ioctl(s, SIOCGIFINDEX, &ifs.ifc_req[i]); + iflist[cntr].index = ifs.ifc_req[i].ifr_ifindex; /* Store the SIOCGIFINDEX number */ + memcpy(&(iflist[cntr++].bcast), hp->h_addr, sizeof(u_int32_t)); + } + } + } + + iflist[cntr].index = 0; // Terminate list + free(ifs.ifc_req); // Stop that leak. + regfree(&preg); + + return iflist; +} + + + +unsigned int ip_compute_checksum(unsigned char *ippdu, int hlen) +{ + unsigned int sum = 0, temp; + unsigned char *p; + unsigned char cs_msb; + unsigned char cs_lsb; + + /* Save original checksum */ + cs_msb = *IP_IPPDU_CHECKSUM_MSB_PTR(ippdu); + cs_lsb = *IP_IPPDU_CHECKSUM_LSB_PTR(ippdu); + + *IP_IPPDU_CHECKSUM_MSB_PTR(ippdu) = 0; + *IP_IPPDU_CHECKSUM_LSB_PTR(ippdu) = 0; + + p = ippdu; + hlen /= 2; /* We'll compute taking two bytes a a time */ + while(hlen--) { sum += ((*p * 256) + *(p + 1)); p += 2; } + while ((temp = (sum >> 16))) { sum = (temp + (sum & 0xFFFF)); } + + /* Restore original checksum */ + *IP_IPPDU_CHECKSUM_MSB_PTR(ippdu) = cs_msb; + *IP_IPPDU_CHECKSUM_LSB_PTR(ippdu) = cs_lsb; + + return(~sum & 0xFFFF); +} + +void ip_update_checksum(unsigned char *ippdu) +{ + unsigned int cs; + + cs = ip_compute_checksum(ippdu, 4 * IP_IPPDU_IHL(ippdu)); + + *IP_IPPDU_CHECKSUM_MSB_PTR(ippdu) = (unsigned char)((cs >> 8) & 0xFF); + *IP_IPPDU_CHECKSUM_LSB_PTR(ippdu) = (unsigned char)(cs & 0xFF); +} + + +static char *IpProtToString( unsigned char prot ) +{ + switch( prot ) + { + case 0x11: + return "UDP"; + case 0x6: + return "TCP"; + case 0x2f: + return "GRE"; + case 0x1: + return "ICMP"; + default: + return "???"; + } +} + +static char *iflistToString( struct iflist *ifp ) +{ + static char str_tr[80+1]; + + sprintf(str_tr, "index=%d, ifname=%s, ifaddr=%ld.%ld.%ld.%ld, ifdstaddr=%ld.%ld.%ld.%ld, flags1=0x%04lx", + ifp->index, ifp->ifname, + (ifp->ifaddr)>>24, ((ifp->ifaddr)&0x00ff0000)>>16, ((ifp->ifaddr)&0x0000ff00)>>8, (ifp->ifaddr)&0x000000ff, + (ifp->ifdstaddr)>>24, ((ifp->ifdstaddr)&0x00ff0000)>>16, ((ifp->ifdstaddr)&0x0000ff00)>>8, + (ifp->ifdstaddr)&0x000000ff, ifp->flags1); + + return str_tr; +} + +static char *iflistLogRToString( struct iflist *ifp, int idx, struct ifsnr *ifnr ) +{ + static char str_tr[MAX_IFLOGTOSTR]; /* + * This makes function: 1) non-reentrant (doesn't matter). + * 2) not useable multiple times by (s)printf. + */ + sprintf(str_tr, "%s", ifp->ifname); + return str_tr; +} + +static char *iflistLogIToString( struct iflist *ifp, int idx, struct ifsnr *ifnr ) +{ + static char str_tr[MAX_IFLOGTOSTR]; /* + * This makes function: 1) non-reentrant (doesn't matter). + * 2) not useable multiple times by (s)printf. + */ + sprintf(str_tr, "%s(%d/%d/%d)", ifp->ifname, idx, ifp->index, ifnr->sock_nr); + return str_tr; +} + +static void bind_to_iface(int fd, int ifindex) +{ + struct sockaddr_ll sll; + + memset(&sll, 0, sizeof(sll)); + sll.sll_family = AF_PACKET; + sll.sll_ifindex = ifindex; + sll.sll_protocol = htons(ETH_P_ALL); + + if (bind(fd, (struct sockaddr *) &sll, sizeof(sll)) == -1) { + syslog(LOG_ERR, "bind_to_iface: Error, bind failed! (rv=-1, errno=%d)", errno); + exit(1); + } +} + +static void copy_ifsnr(struct ifsnr *from, struct ifsnr *to) +{ + int i; + + for (i=0; i<MAXIF; ++i) + { + to[i].sock_nr = from[i].sock_nr; + to[i].ifindex = from[i].ifindex; + } +} + +static int find_sock_nr(struct ifsnr *l, int ifidx) +{ + int i; + + for (i=0; i<MAXIF; ++i) + if (l[i].ifindex == ifidx) return l[i].sock_nr; + /* not found */ + return -1; +} + |