ip_masq_dplay-0.3.00/0040755000000000000500000000000007176101062012727 5ustar rootsrcip_masq_dplay-0.3.00/Makefile0100644000000000000500000000277407176100624014401 0ustar rootsrcCC = gcc KSRC = /usr/src/linux KCFG = $(KSRC)/.config KVER = $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION) CFLAGS = -Wall -Wstrict-prototypes -Winline -O2 -fomit-frame-pointer \ #-DGR_VERTICAL=131 -DGR_LUCORNER=170 -DGR_LBCORNER=144 ifneq ($(wildcard $(KCFG)), $(KCFG)) all install ip_masq_dplay.o: @echo Configure the kernel before compiling the module >&2 @exit 1 else include $(KCFG) CFLAGS += $(shell $(CC) -fno-strict-aliasing -S -o /dev/null -xc /dev/null >/dev/null 2>&1 && echo "-fno-strict-aliasing") $(shell egrep '^(VERSION|PATCHLEVEL|SUBLEVEL|EXTRAVERSION|ARCH)' $(KSRC)/Makefile >Makefile.arch) include Makefile.arch $(shell egrep -v '^|^[^ :]*:' $(KSRC)/arch/$(ARCH)/Makefile >Makefile.arch) include Makefile.arch all: ip_masq_dplay.o install: ip_masq_dplay.o mkdir -p $(INSTALL_MOD_PATH)/lib/modules/$(KVER)/ipv4 cp -f $< $(INSTALL_MOD_PATH)/lib/modules/$(KVER)/ipv4 depmod -a $(KVER) ip_masq_dplay.o: ip_masq_dplay.c ifneq ($(KVER), $(shell uname -r)) @echo -e warning: compiling for kernel version $(KVER), while running `uname -r`\\n >&2 endif ifneq ($(CONFIG_IP_MASQUERADE_MOD), y) @echo -n 'Turn on ' ifneq ($(CONFIG_EXPERIMENTAL), y) @echo -ne '"Prompt for development and/or incomplete code/drivers" (the 1st menu)\nand ' endif @echo -e '"IP: masquerading special modules support" ("Networking options" menu)\nin the kernel config. \033[1;37;41m!!!! RTFM !!!!\033[0m' @exit 1 endif $(CC) $(CFLAGS) -I$(KSRC)/include -c $< -o $@ endif clean: rm -fv Makefile.arch ip_masq_dplay.o ip_masq_dplay-0.3.00/ChangeLog0100644000000000000500000000042007176100673014501 0ustar rootsrc* 26 Oct 2000 * v0.3.00 ~~~~~~~~~~~~~~~ ~~~~~~~ - Added proc_fs read support * 30 Sep 2000 * v0.2.00 ~~~~~~~~~~~~~~~ ~~~~~~~ - Added server forwarding functionality * 25 Jul 2000 * v0.1.00 ~~~~~~~~~~~~~~~ ~~~~~~~ - First public release vim:set ts=4: ip_masq_dplay-0.3.00/README0100644000000000000500000001012107176100646013606 0ustar rootsrc ip_masq_dplay 0.3.00 ~~~~~~~~~~~~~~~~~~~~~~ This is a Linux kernel module that provides masquerading support for the Microsoft(R) DirectX(R) DirectPlay(R) protocol. It allows users behind the masquerading server to initiate DirectPlay client gaming sessions with servers out in the "real world". It also allows users to forward incoming DirectPlay connections to a local host behind the masquerade server. Requirements ~~~~~~~~~~~~ - 2.2.x kernel - ``Prompt for development and/or incomplete code/drivers'' ("Code maturity level options" menu) and ``IP: masquerading special modules support'' ("Networking options" menu) options turned on. - Make 3.78+ (since I still haven't figured out the makefile problem with 3.77). Compiling/Installing ~~~~~~~~~~~~~~~~~~~~ 1. cd /usr/src/ip_masq_dplay/; make install 2. insmod it and enjoy. Module Parameters ~~~~~~~~~~~~~~~~~ host - Use "host=www.xxx.yyy.zzz" when insmod'ing this module to forward incoming DirectPlay connection requests to the specified local host. Runtime configuration/statistics ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To see a list of masqueraded DirectPlay sessions, as well as the current value of the "host" parameter, look in /proc/net/ip_masq/dplay. This will only be present if you have enabled PROC_FS support in your kernel. Known bugs ~~~~~~~~~~ 1. Doesn't yet check for conflicting DirectPlay ports, so multiple clients behind a masquerading server could potentially try to use the same port. Most DirectPlay games, however, seem to pick their two ports randomly (out of the 2300-2400 range), so there is generally only a 1/50 chance that your client will conflict with another behind the server. Simply telling the game to reconnect should force it to try a new port, and thus work just fine. 2. More than one client behind a masquerade server cannot connect to the SAME external host. This is not a problem with the module, per se, but rather a limitation in the DirectPlay protocol. I'm still trying to see if I can work around it. 3. When hosting a DirectPlay game behind your masquerade server, clients on the "inside" (other clients on your LAN) do not get proper UDP/TCP packets from clients on the "outside" (clients on the Internet, or WAN). The LAN clients send their information properly to the WAN clients, but the reverse packets get lost. (Again, limitation in the DirectPlay protocol, probably directly related to Known Bug #2). I believe a "repeater" or "rebroadcaster" system will work to resolve this (the module re-transmits all incoming UDP/TCP packets from WAN clients to all clients on the LAN). This is just a theory, however, and it may not work, or it may only work for some games. 4. The "server forwarding" feature (to forward incoming DirectPlay requests to a local host) may not work with very many games. It has only been tested with Baldur's Gate II: Shadows of Amn, and I've got a sneaking suspicion that my method for identifying packets (packet length) is not consistent from game to game for these particular packets. Only further testing will verify this. 5. There is a problem with the Makefile and version 3.77 of GNU Make. I have not yet figured out what the problem is being caused by, but upgrading to version 3.78 or better of GNU Make should resolve the issue. Contributors ~~~~~~~~~~~~ - Matthias Tichy: Provided the initial code necessary for outputting the module statistics to the PROC filesystem. Acknowledgements ~~~~~~~~~~~~~~~~ Basically this entire thing is just a hack on the ip_masq_portfw module. In the future, I hope to add enough useful features so that it will constitute more than just an out and out hack. However, currently this is little more than a dynamic port fowarder. Also, I used the ip_masq_icq module for its Makefile, and some other code features. Most of the credit should go mainly to those two bits of code and their developers; I'm just tying it together :) Homepage ~~~~~~~~ http://nodezero.moscow.com/ip_masq_dplay/ Author ~~~~~~ keith howe vim:set ts=4: ip_masq_dplay-0.3.00/TODO0100644000000000000500000000110107176100624013410 0ustar rootsrc1. Remap all outgoing DirectPlay connections into open ports in the 2300-2400 range, so that there are no conflicts. The downside of doing this (once I or you or whoever decides to get around it) is that all of the outgoing packets need to be remapped. I think. 2. Watch the DirectPlay protocol in work some more. I still haven't the foggiest idea what it's doing half the time. 3. Add proper logging support/options. 4. Expand proc_fs support to allow modification of module settings. 5. Track open connections accurately. 6. Tons of other things I'm sure... ip_masq_dplay-0.3.00/ip_masq_dplay.c0100644000000000000500000003440007176100624015716 0ustar rootsrc#define __KERNEL__ #define MODULE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DPLAY_PORT_MIN 2300 #define DPLAY_PORT_MAX 2400 #define DPLAY_PORT_SRV 47624 #define cl ((struct dplay_session *)ms->app_data) static struct ip_masq_app *dplay_app; struct dplay_session { struct list_head list; __u32 client_addr, server_addr; __u16 client_tcp_port, client_udp_port, server_tcp_port, server_udp_port; }; static struct ip_masq_mod *mmod_self = NULL; static struct list_head session_list; static rwlock_t dplay_lock = RW_LOCK_UNLOCKED; static char *host = NULL; __u32 host_addr = 0; static __inline__ int dplay_session_del (__u16 protocol, __u16 client_port, __u32 client_addr) { struct dplay_session *n; struct list_head *entry; struct list_head *list = &session_list; __u16 port; int nent; if (protocol != IPPROTO_UDP && protocol != IPPROTO_TCP) return 1; if (client_port < DPLAY_PORT_MIN || client_port > DPLAY_PORT_MAX) return 1; nent = atomic_read (&mmod_self->mmod_nent); write_lock_bh (&dplay_lock); // iterate through the list of entries // well, I hope that's what it's doing for (entry = list->next; entry != list; entry = entry->next) { n = list_entry (entry, struct dplay_session, list); // compare the passed port to the appropriate stored // port based on the protocol given if (protocol == IPPROTO_TCP) { port = n->client_tcp_port; } else { port = n->client_udp_port; } if (port == client_port && (!client_addr || n->client_addr == client_addr)) { entry = n->list.prev; list_del (&n->list); ip_masq_mod_dec_nent (mmod_self); kfree_s (n, sizeof (struct dplay_session)); MOD_DEC_USE_COUNT; } } write_unlock_bh (&dplay_lock); return nent==atomic_read (&mmod_self->mmod_nent) ? ESRCH : 0; } static __inline__ void dplay_session_flush (void) { struct dplay_session *n; struct list_head *l, *e; write_lock_bh (&dplay_lock); l = &session_list; while ((e = l->next) != l) { ip_masq_mod_dec_nent (mmod_self); n = list_entry (e, struct dplay_session, list); list_del (e); kfree_s (n, sizeof (*n)); MOD_DEC_USE_COUNT; } write_unlock_bh (&dplay_lock); } static __inline__ struct dplay_session * dplay_session_lookup (__u16 protocol, __u16 client_port, __u32 client_addr) { struct dplay_session *n = NULL; struct list_head *l, *e; __u16 port; if ((client_port < DPLAY_PORT_MIN || client_port > DPLAY_PORT_MAX) && client_port != 0) return NULL; l = &session_list; for (e = l->next; e != l; e = e->next) { n = list_entry (e, struct dplay_session, list); if (protocol == IPPROTO_TCP) { port = n->client_tcp_port; } else if (protocol == IPPROTO_UDP) { port = n->client_udp_port; } else { return NULL; } if ((!client_port || port == client_port) && (!client_addr || n->client_addr == client_addr)) return n; } return NULL; } static __inline__ int dplay_session_add (__u16 protocol, __u16 client_port, __u32 client_addr) { struct dplay_session *npf; if (protocol != IPPROTO_UDP && protocol != IPPROTO_TCP) return 1; if (client_port < DPLAY_PORT_MIN || client_port > DPLAY_PORT_MAX) return 1; npf = (struct dplay_session*) kmalloc (sizeof (struct dplay_session), GFP_KERNEL); if (!npf) return ENOMEM; MOD_INC_USE_COUNT; memset (npf, 0, sizeof (*npf)); npf->client_tcp_port = 0; npf->client_udp_port = 0; npf->server_tcp_port = 0; npf->server_udp_port = 0; npf->client_addr = client_addr; npf->server_addr = 0; if (protocol == IPPROTO_UDP) { npf->client_udp_port = client_port; } else { npf->client_tcp_port = client_port; } INIT_LIST_HEAD (&npf->list); write_lock_bh (&dplay_lock); list_add (&npf->list, &session_list); write_unlock_bh (&dplay_lock); ip_masq_mod_inc_nent (mmod_self); return 0; } #ifdef CONFIG_PROC_FS int dplay_get_info(char *buffer, char **start, off_t offset, int length, int dummy); static struct proc_dir_entry proc_masq_dplay = { 0, 5, "dplay", S_IFREG | S_IRUGO, 1, 0, 0, 0, &proc_net_inode_operations, dplay_get_info }; #define proc_ent &proc_masq_dplay #else #define proc_ent NULL #endif static int masq_dplay_start (struct ip_masq_app *mapp, struct ip_masq *ms); static int masq_dplay_fin (struct ip_masq_app *mapp, struct ip_masq *ms); static int masq_dplay_pkt_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, __u32 maddr); static int masq_dplay_pkt_in (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, __u32 maddr); static struct ip_masq_app ip_masq_dplay = { NULL, // next // "dplay", // name // 0, // type // assigned automatically by register_ip_masq_app 0, // n_attach // assigned automatically by register_ip_masq_app masq_dplay_start, // ip_masq_init_1 // masq_dplay_fin, // ip_masq_done_1 // masq_dplay_pkt_out, // pkt_out // masq_dplay_pkt_in // pkt_in // }; static int masq_dplay_start (struct ip_masq_app *mapp, struct ip_masq *ms) { // initialize the ms->app_data field, since otherwise // masquerading does not seem to take place? if (!(ms->app_data = kmalloc (sizeof (struct dplay_session), GFP_ATOMIC))) return -ENOMEM; cl->client_tcp_port = 0; cl->client_udp_port = 0; cl->client_addr = 0; cl->server_tcp_port = 0; cl->server_udp_port = 0; cl->server_addr = 0; return 0; } static int masq_dplay_fin (struct ip_masq_app *mapp, struct ip_masq *ms) { // we don't actually want to do this, but oh well... if (cl->client_tcp_port) { dplay_session_del (IPPROTO_TCP, cl->client_tcp_port, cl->client_addr); printk (KERN_INFO "ip_masq_dplay: Session between %u.%u.%u.%u and %u.%u.%u.%u has expired.\n", NIPQUAD (cl->client_addr), NIPQUAD (cl->server_addr)); } kfree (ms->app_data); ms->app_data = NULL; return 0; } static int masq_dplay_pkt_in (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, __u32 maddr) { printk (KERN_INFO "ip_masq_dplay: is anything happening anywhere?\n"); if (ms->dport == DPLAY_PORT_SRV || htons (ms->dport) == DPLAY_PORT_SRV) { printk (KERN_INFO "ip_masq_dplay: hello jello!\n"); } return 0; } static int masq_dplay_pkt_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, __u32 maddr) { struct sk_buff *skb = *skb_p; struct iphdr *iph = skb->nh.iph; __u8 *data = (__u8 *)((struct udphdr *)&(((__u8 *)iph)[iph->ihl << 2])+1); unsigned len = skb->len - (data - skb->h.raw); struct dplay_session *ds; if (iph->protocol != IPPROTO_UDP) return 0; if (len != 52) return 0; cl->client_tcp_port = (*(data + 6) << 8) | *(data + 7); if (cl->client_tcp_port < DPLAY_PORT_MIN || cl->client_tcp_port > DPLAY_PORT_MAX) return 0; cl->server_tcp_port = htons (ms->dport); cl->client_addr = ms->saddr; cl->server_addr = ms->daddr; dplay_session_add (IPPROTO_TCP, cl->client_tcp_port, cl->client_addr); ds = dplay_session_lookup (IPPROTO_TCP, cl->client_tcp_port, cl->client_addr); if (!ds) { printk (KERN_WARNING "ip_masq_dplay: DirectPlay session could not be tracked!\n"); return 0; } ds->server_addr = cl->server_addr; ds->server_tcp_port = cl->server_tcp_port; printk (KERN_INFO "ip_masq_dplay: %u.%u.%u.%u is connecting to %u.%u.%u.%u.\nip_masq_dplay: --- Client TCP Port: %u.\n", NIPQUAD (cl->client_addr), NIPQUAD (cl->server_addr), cl->client_tcp_port); return 0; } static int dplay_in_rule (const struct sk_buff *skb, const struct iphdr *iph); static struct ip_masq * dplay_in_create (const struct sk_buff *skb, const struct iphdr *iph, __u32 maddr); static int dplay_out_rule (const struct sk_buff *skb, const struct iphdr *iph); static int dplay_out_update (const struct sk_buff *skb, const struct iphdr *iph, struct ip_masq *ms); static struct ip_masq * dplay_out_create (const struct sk_buff *skb, const struct iphdr *iph, __u32 maddr); static struct ip_masq_mod dplay_mod = { NULL, // next // NULL, // next_reg // "dplay", // name // ATOMIC_INIT(0), // nent // ATOMIC_INIT(0), // refcnt // proc_ent, NULL, NULL, // masq_mod_init // NULL, // masq_mod_done // dplay_in_rule, NULL, dplay_in_create, dplay_out_rule, dplay_out_update, dplay_out_create }; static int dplay_in_rule (const struct sk_buff *skb, const struct iphdr *iph) { const __u16 *portp = (__u16 *)&(((char *)iph)[iph->ihl*4]); struct dplay_session *ds; int ret = IP_MASQ_MOD_NOP; read_lock (&dplay_lock); ds = dplay_session_lookup(iph->protocol, ntohs (portp[1]), 0); read_unlock (&dplay_lock); if (ds) ret = IP_MASQ_MOD_ACCEPT; if (host_addr && (ntohs (portp[1]) == DPLAY_PORT_SRV)) { printk (KERN_INFO "ip_masq_dplay: Connection request from %u.%u.%u.%u being forwarded to %u.%u.%u.%u. %u\n", NIPQUAD(iph->saddr), NIPQUAD(host_addr), iph->tos); ret = IP_MASQ_MOD_ACCEPT; } return ret; } static struct ip_masq * dplay_in_create (const struct sk_buff *skb, const struct iphdr *iph, __u32 maddr) { const __u16 *portp = (__u16 *)&(((char *)iph)[iph->ihl*4]); __u16 port; struct ip_masq *ms = NULL; struct dplay_session *ds; write_lock (&dplay_lock); if (ntohs (portp[1]) == DPLAY_PORT_SRV) { // somehow we need to get the udp/tcp ports the server is sending back to the client, so we can add // these ports to our session list... ms = ip_masq_new (iph->protocol, iph->daddr, portp[1], host_addr, portp[1], iph->saddr, portp[0], 0); // this should forward our packet to the local server ip_masq_listen (ms); } else if ((ds = dplay_session_lookup (iph->protocol, ntohs (portp[1]), 0))) { if (iph->protocol == IPPROTO_TCP) port = htons (ds->client_tcp_port); else port = htons (ds->client_udp_port); ms = ip_masq_new (iph->protocol, iph->daddr, portp[1], ds->client_addr, port, iph->saddr, portp[0], 0); ip_masq_listen (ms); } write_unlock (&dplay_lock); return ms; } static int dplay_out_rule (const struct sk_buff *skb, const struct iphdr *iph) { return IP_MASQ_MOD_NOP; } static struct ip_masq * dplay_out_create (const struct sk_buff *skb, const struct iphdr *iph, __u32 maddr) { return NULL; } static int dplay_out_update (const struct sk_buff *skb, const struct iphdr *iph, struct ip_masq *ms) { __u8 *data = (__u8 *)((struct tcphdr *)&(((__u8 *)iph)[iph->ihl << 2])+1); unsigned len = skb->len - (data - skb->h.raw); struct dplay_session *ds; __u16 port; if (iph->protocol != IPPROTO_TCP) return 0; if ((len == 128) && (*(data + 4) == 0x2)) { port = ((*(data + 6)) << 8) | (*(data + 7)); ds = dplay_session_lookup (iph->protocol, port, 0); if (!ds) { dplay_session_add (iph->protocol, port, iph->saddr); ip_masq_mod_dec_nent (&dplay_mod); MOD_DEC_USE_COUNT; } return 0; } read_lock (&dplay_lock); ds = dplay_session_lookup (iph->protocol, 0, iph->saddr); read_unlock (&dplay_lock); if (!ds) return 0; if ((len == 134) && (*(data + 112) == 0x2) && (*(data + 113) == 0x0)) { port = ((*(data + 114)) << 8) | (*(data + 115)); if (port < DPLAY_PORT_MIN || port > DPLAY_PORT_MAX) return 0; ds->client_udp_port = port; printk (KERN_INFO "ip_masq_dplay: --- Client UDP Port: %u.\n", ds->client_udp_port); return 0; } else if ((len == 339) && (*(data + 242) == 0x2) && (*(data + 243) == 0x0)) { port = ((*(data + 244)) << 8) | (*(data + 245)); if (port < DPLAY_PORT_MIN || port > DPLAY_PORT_MAX) return 0; ds->client_udp_port = port; return 0; } return 0; } #ifdef CONFIG_PROC_FS int dplay_get_info(char *buffer, char **start, off_t offset, int length, int dummy) { int len=0; struct dplay_session *n = NULL; struct list_head *l, *e; if (offset > 0) return 0; l = &session_list; if (!host_addr) { len = sprintf(buffer, "Host address: \n"); } else { len = sprintf(buffer, "Host address: %u.%u.%u.%u\n", NIPQUAD (host_addr)); } len += sprintf(buffer+len, "Masquerading DirectPlay connections:\n"); for (e = l->next; e != l; e = e->next) { n = list_entry (e, struct dplay_session, list); len += sprintf(buffer+len, "client: %u.%u.%u.%u <---> server: %u.%u.%u.%u\n", NIPQUAD (n->client_addr), NIPQUAD (n->server_addr)); } *start = buffer; return len; } #endif __initfunc(int dplay_init(void)) { int ret, i, back = 0, n = 0; __u8 q[4] = {0,0,0,0}; char temp[16]; INIT_LIST_HEAD(&session_list); ret = register_ip_masq_mod ((mmod_self=&dplay_mod)); if (!ret) { if ((host) && (strlen (host) < 16)) { for (i = 0; i < strlen (host) + 1; i++) { if ((host[i] == '.' || host[i] == '\0') && (n < 4)) { if (i - back > 3) break; strncpy(temp, (host + back), i - back); temp[i - back] = '\0'; q[n] = (__u8) simple_strtoul (temp, NULL, 10); back = i + 1; n++; } } if (n != 4) q[0] = q[1] = q[2] = q[3] = 0; } host_addr = q[0] | (q[1] << 8) | (q[2] << 16) | (q[3] << 24); if (host_addr) ip_masq_mod_inc_nent (&dplay_mod); // increases our entry(?) count to hear incoming server requests. dplay_app = kmalloc (sizeof (struct ip_masq_app), GFP_KERNEL); memcpy (dplay_app, &ip_masq_dplay, sizeof (struct ip_masq_app)); ret = register_ip_masq_app (dplay_app, IPPROTO_UDP, DPLAY_PORT_SRV); if (!ret) { printk (KERN_INFO "ip_masq_dplay: Listening to outbound connections on port %u.\n", DPLAY_PORT_SRV); if (host_addr) printk (KERN_INFO "ip_masq_dplay: Inbound connections will be forwarded to %u.%u.%u.%u.\n", NIPQUAD (host_addr)); } } return ret; } int dplay_done(void) { if (host_addr) ip_masq_mod_dec_nent (&dplay_mod); // decreases our entry(?) count. unregister_ip_masq_app (dplay_app); kfree (dplay_app); return unregister_ip_masq_mod (&dplay_mod); } #ifdef MODULE EXPORT_NO_SYMBOLS; MODULE_DESCRIPTION ("DirectPlay Masquerading Module"); MODULE_AUTHOR ("nezroy"); MODULE_PARM (host, "0-1s"); int init_module(void) { printk (KERN_INFO "ip_masq_dplay: Starting DirectPlay(R) masquerade module.\n"); if (dplay_init() != 0) { printk (KERN_WARNING "ip_masq_dplay: Module did not start successfully!\n"); return -EIO; } return 0; } void cleanup_module(void) { if (dplay_done() != 0) printk (KERN_WARNING "ip_masq_dplay: Can't remove module!\n"); else printk (KERN_INFO "ip_masq_dplay: Stopping DirectPlay(R) masquerade module.\n"); } #endif // MODULE // /* vim:set ts=4: */