IP Routing in Windows XP Pro

[Guest]

Hello

I am developing a multi-hop ad-hoc wireless network as part of an undergraduate team at Stanford, for our Senior Projects. Our main focus is on the routing algorithms that work well under highly dynamic conditions, and we will simulate these algorithms using the NS2 simulator. However, it would be great if we could also implement the network and display it at an upcoming Software Fair (6/09). My question pertains to whether there is an easy way to do this. Once again, this is not a homework-help style request... we just want an easy way to jazz up the presentation of our research work

The basic idea of multi-hop ad-hoc networks is pretty straightforward, and can be phrased in many different ways. Lets think of it as three nodes A,B,C set up such that A cannot directly talk to C (perhaps they are out of range). Both A and C can, however, talk to B (some people refer to this as the 'hidden node problem'). In order for the system to work, B should efficiently and automatically relay all traffic from A meant for C. This should happen in a transparent manner (A never knows he is being routed through B... he just 'sees' C), and the routing paths should update automatically whenever network topology changes. Assume for now that we have algorithms that tell you (A) that to get to C you need to go through B

After some research, my first thought is to implement an NDIS Intermediate Driver using the Windows DDK. There is a 'passthru' sample that could form the basis of this code. For people unfamiliar with the NDIS architecture, this is just a way to 'intercept' IP Packets sent up from the NIC driver before they reach the higher layers (and also when they are sent down from higher layers). Conceivably, we could maintain routing tables at that level and update 'send' and 'receive' fields as we go, adding a GOAL field to the IP packet to determine the ultimate destination. In the trivial example, then, A's original packets would initially have SRC=A,DST=C. The Intermediate Driver would magically know that it should route through B (assume this blackbox functionality) and it would update the packet to SRC=A,DST=B,GOAL=C. Thus, when the packet is passed to the NIC driver, it will send out an ARP request for B and not for C. Sending an ARP request for C would fail since C is out of range, so this is good. Anyway the rest should be obvious... B receives the packet and sees that it is not meant for her (GOAL!=DST) and so routes it on to C. C receives it and passes the packet up to the higher layers (maybe removing the GOAL field for transparency. I realize that there might be some issues with the congestion control protocol in TCP, but I am hoping they are not impossible to resolve

After explaining this somewhat tedious exercise, I still wonder if there is an easier way to do this. Windows XP has an 'IP Routing' feature which is meant for use when, e.g. there are multiple NICs on the machine (on different subnets) and you want to route packets between them. If you do ipconfig/all you can see that IP Routing is off by default

I was wondering that somebody could tell me if either of the following two options is possible

1. Use the IP routing functionality as-is, but fool it into 'routing' in the ad-hoc scenario I mentioned above. Importantly, the nodes you are routing between will now be in the same subnet, so this is not the standard definition of the routing that a 'router' does... perhaps I should call this 'relaying'

2. Use the API functionality exposed by windows for IP routing (using the IP Helper API - see msdn). This API is not too well documented and if somebody knows where I can read more about it, the help would be appreciated. Basically, I think it lets you program various IP-related things, e.g. the IP address of your machine. Importantly, it has functions to manipulate the IP routing functionality mentioned above... turning it on/off, adding entries to the routing table, etc. What if you add entries that are in the same subnet (in the trivial example, add C|B in the routing table for A, C|C for B, etc). Will this work? or is it too high in the layered architecture to work (the NIC might reject packets not meant for it... not sure how ARP will interface with IP routing). Any light on this is appreciated... this there is also something called 'Advanced Networking Pack' for windows that I have no clue about

Sorry about the lengthy description. Just wanted to be unambiguous. Summary: Looking for a no-hassle way to showcase our research work on actual working machines (maybe classy tablet-PCs that we let showgoers walk around with!).

Reply direct to (e-mail address removed) or group-post.

thanks,
/t.

 

[Randy]

One suggestion might be to make two different wireless
connections on machine "b", assign them both a different
static IP and bridge them. That way "a" can talk to b on
one connection, "c" can talk to "b" on the other, and
with the bridge in place, "a" should be able to see "c".
I think I might be missing the boat on the way you want
to do it, but this solution might work.

-----Original Message-----
Hello,

I am developing a multi-hop ad-hoc wireless network as

part of an undergraduate team at Stanford, for our Senior
Projects. Our main focus is on the routing algorithms
that work well under highly dynamic conditions, and we
will simulate these algorithms using the NS2 simulator.
However, it would be great if we could also implement the
network and display it at an upcoming Software Fair
(6/09). My question pertains to whether there is an easy
way to do this. Once again, this is not a homework-help
style request... we just want an easy way to jazz up the
presentation of our research work.

The basic idea of multi-hop ad-hoc networks is pretty

straightforward, and can be phrased in many different
ways. Lets think of it as three nodes A,B,C set up such
that A cannot directly talk to C (perhaps they are out of
range). Both A and C can, however, talk to B (some people
refer to this as the 'hidden node problem'). In order for
the system to work, B should efficiently and
automatically relay all traffic from A meant for C. This
should happen in a transparent manner (A never knows he
is being routed through B... he just 'sees' C), and the
routing paths should update automatically whenever
network topology changes. Assume for now that we have
algorithms that tell you (A) that to get to C you need to
go through B.

After some research, my first thought is to implement an

NDIS Intermediate Driver using the Windows DDK. There is
a 'passthru' sample that could form the basis of this
code. For people unfamiliar with the NDIS architecture,
this is just a way to 'intercept' IP Packets sent up from
the NIC driver before they reach the higher layers (and
also when they are sent down from higher layers).
Conceivably, we could maintain routing tables at that
level and update 'send' and 'receive' fields as we go,
adding a GOAL field to the IP packet to determine the
ultimate destination. In the trivial example, then, A's
original packets would initially have SRC=A,DST=C. The
Intermediate Driver would magically know that it should
route through B (assume this blackbox functionality) and
it would update the packet to SRC=A,DST=B,GOAL=C. Thus,
when the packet is passed to the NIC driver, it will send
out an ARP request for B and not for C. Sending an ARP
request for C would fail since C is out of range, so this
is good. Anyway the rest should be obvious... B receives
the packet and sees that it is not meant for her (GOAL!
=DST) and so routes it on to C. C receives it and passes
the packet up to the higher layers (maybe removing the
GOAL field for transparency. I realize that there might
be some issues with the congestion control protocol in
TCP, but I am hoping they are not impossible to resolve.

After explaining this somewhat tedious exercise, I still

wonder if there is an easier way to do this. Windows XP
has an 'IP Routing' feature which is meant for use when,
e.g. there are multiple NICs on the machine (on different
subnets) and you want to route packets between them. If
you do ipconfig/all you can see that IP Routing is off by
default.

I was wondering that somebody could tell me if either of

the following two options is possible:

1. Use the IP routing functionality as-is, but fool it

into 'routing' in the ad-hoc scenario I mentioned above.
Importantly, the nodes you are routing between will now
be in the same subnet, so this is not the standard
definition of the routing that a 'router' does... perhaps
I should call this 'relaying'.

2. Use the API functionality exposed by windows for IP

routing (using the IP Helper API - see msdn). This API is
not too well documented and if somebody knows where I can
read more about it, the help would be appreciated.
Basically, I think it lets you program various IP-related
things, e.g. the IP address of your machine. Importantly,
it has functions to manipulate the IP routing
functionality mentioned above... turning it on/off,
adding entries to the routing table, etc. What if you add
entries that are in the same subnet (in the trivial
example, add C|B in the routing table for A, C|C for B,
etc). Will this work? or is it too high in the layered
architecture to work (the NIC might reject packets not
meant for it... not sure how ARP will interface with IP
routing). Any light on this is appreciated... this there
is also something called 'Advanced Networking Pack' for
windows that I have no clue about.

Sorry about the lengthy description. Just wanted to be

unambiguous. Summary: Looking for a no-hassle way to
showcase our research work on actual working machines
(maybe classy tablet-PCs that we let showgoers walk
around with!).

 

[Bill Castner]

The peer-to-peer networking features available as part and parcel of the
IPv6 advanced networking package should be your starting point. From a
network design perspective you need to create what Microsoft calls a network
Graph so that workstation B in your example functions in the role your
require.

With Microsoft Peer-to-peer the logical design of your planned network
becomes trivial. What is decidenly non-trivial is then the hardware
required to reasonably and efficiently create a "mesh" network. Here the
relatively newer 802.11x devices begin to offer reasonable hardware support
for Mesh networking; and while not commercially available at the moment,
the specifications and plans in the 802.11x product space are quite exciting
to allow a reasonable implementation of your proposed network in the next
four years.

Hello,

I am developing a multi-hop ad-hoc wireless network as part of an

undergraduate team at Stanford, for our Senior Projects. Our main focus is
on the routing algorithms that work well under highly dynamic conditions,
and we will simulate these algorithms using the NS2 simulator. However, it
would be great if we could also implement the network and display it at an
upcoming Software Fair (6/09). My question pertains to whether there is an
easy way to do this. Once again, this is not a homework-help style
request... we just want an easy way to jazz up the presentation of our
research work.

The basic idea of multi-hop ad-hoc networks is pretty straightforward, and

can be phrased in many different ways. Lets think of it as three nodes A,B,C
set up such that A cannot directly talk to C (perhaps they are out of
range). Both A and C can, however, talk to B (some people refer to this as
the 'hidden node problem'). In order for the system to work, B should
efficiently and automatically relay all traffic from A meant for C. This
should happen in a transparent manner (A never knows he is being routed
through B... he just 'sees' C), and the routing paths should update
automatically whenever network topology changes. Assume for now that we have
algorithms that tell you (A) that to get to C you need to go through B.

After some research, my first thought is to implement an NDIS Intermediate

Driver using the Windows DDK. There is a 'passthru' sample that could form
the basis of this code. For people unfamiliar with the NDIS architecture,
this is just a way to 'intercept' IP Packets sent up from the NIC driver
before they reach the higher layers (and also when they are sent down from
higher layers). Conceivably, we could maintain routing tables at that level
and update 'send' and 'receive' fields as we go, adding a GOAL field to the
IP packet to determine the ultimate destination. In the trivial example,
then, A's original packets would initially have SRC=A,DST=C. The
Intermediate Driver would magically know that it should route through B
(assume this blackbox functionality) and it would update the packet to
SRC=A,DST=B,GOAL=C. Thus, when the packet is passed to the NIC driver, it
will send out an ARP request for B and not for C. Sending an ARP request for
C would fail since C is out of range, so this is good. Anyway the rest
should be obvious... B receives the packet and sees that it is not meant for
her (GOAL!=DST) and so routes it on to C. C receives it and passes the
packet up to the higher layers (maybe removing the GOAL field for
transparency. I realize that there might be some issues with the congestion
control protocol in TCP, but I am hoping they are not impossible to resolve.

After explaining this somewhat tedious exercise, I still wonder if there

is an easier way to do this. Windows XP has an 'IP Routing' feature which is
meant for use when, e.g. there are multiple NICs on the machine (on
different subnets) and you want to route packets between them. If you do
ipconfig/all you can see that IP Routing is off by default.

I was wondering that somebody could tell me if either of the following two options is possible:

1. Use the IP routing functionality as-is, but fool it into 'routing' in

the ad-hoc scenario I mentioned above. Importantly, the nodes you are
routing between will now be in the same subnet, so this is not the standard
definition of the routing that a 'router' does... perhaps I should call this
'relaying'.

2. Use the API functionality exposed by windows for IP routing (using the

IP Helper API - see msdn). This API is not too well documented and if
somebody knows where I can read more about it, the help would be
appreciated. Basically, I think it lets you program various IP-related
things, e.g. the IP address of your machine. Importantly, it has functions
to manipulate the IP routing functionality mentioned above... turning it
on/off, adding entries to the routing table, etc. What if you add entries
that are in the same subnet (in the trivial example, add C|B in the routing
table for A, C|C for B, etc). Will this work? or is it too high in the
layered architecture to work (the NIC might reject packets not meant for
it... not sure how ARP will interface with IP routing). Any light on this is
appreciated... this there is also something called 'Advanced Networking
Pack' for windows that I have no clue about.

Sorry about the lengthy description. Just wanted to be unambiguous.

Summary: Looking for a no-hassle way to showcase our research work on actual
working machines (maybe classy tablet-PCs that we let showgoers walk around
with!).