Although achieving host mobility for native applications is straight-forward, many legacy applications will remain /ROAM unaware. In designing a solution for these applications, our primary goals are to remain transparent to both applications and the TCP/IP protocol stack. The main host modification required for legacy applications is a user-level ROAM proxy. The proxy serves the following functions: (1) encapsulates and decapsulates IP packets within packets, (2) determines the triggers of remote hosts, and (3) sends the local private trigger to remote hosts. Table 1 gives the notations used in this section.
We assume that each host has a current IP address denoted by and a home IP address (e.g., the address of the host in its home network) denoted by . The home address is stored in the end-host's DNS record, and it is used as a source address for all packets sent by legacy applications on . Each host runs a ROAM proxy that maintains a public trigger where is computed as a hash on 's home IP address, and contains the current address of and 's port number, i.e., . The proxy is responsible for updating the trigger every time the host's current IP address changes.
Figure 6 shows a typical data path in a legacy application, where a client running on host is accessing a web server running on host . (Figure 8 shows the pseudo-code executed by an ROAM proxy.) The source and the destination addresses in the headers of the packets sent by CA are the host IP addresses of and , respectively. Upon capturing the packet, encapsulates it in and proxy headers and sends it to through using UDP. 6The identifier of the packet is set to 's public trigger identifier, i.e., (see function ip_receive in Figure 8). The format of the packets handled by proxies is shown in Figure 7
When this packet arrives at (see ), 's proxy () strips off the and proxy headers and forwards the packet to the local application. In addition, checks to see if the packet is addressed to its own public trigger. If it is, then knows that 's proxy () does not have a private trigger for , so should send one. As an optimization, sets a timeout to see if it can piggyback the trigger on a packet sent from 's application (). Otherwise, when the timeout expires, 's proxy sends the private trigger in a separate packet. An end-host chooses private triggers on a per flow or a per communication peer basis. This precludes a malicious end-host from learning the private trigger used by (the flows of) another end-host and eavesdropping on it.
Assume that does send a packet before the timeout expires, then piggybacks 's local private trigger on the outgoing packet to . Since, does not know 's private trigger, it uses 's public trigger (as ). When receives this packet, it inserts 's private trigger into its translation table with as the key. In addition, sees that the packet was sent to its own public trigger, so it also sets a timeout and tries to piggyback its private trigger to .
When changes its IP address from to as a result of moving from one subnetwork to another, will insert a trigger containing the new IP address into and remove the trigger containing the old IP address . The trigger identifier itself remains the same. Effectively, host mobility is masked by the network from the communicating peer, and end-to-end connectivity is preserved.
While each end-host initially chooses its private triggers such that they are stored on nearby servers, end-hosts may eventually move far from those servers. To address this problem, each end-host can re-sample trigger servers either periodically or once it notices that its current private triggers are experiencing a high latency. The new private triggers can be exchanged using a mechanism identical to the one used to exchange the original private triggers via the public triggers. The only change occurs in the i3_receive function: in addition to comparing the packet identifier to the the host's public trigger, we also compare it to the previous private trigger identifier, and then send out the new private trigger if necessary. This operation will be transparent to applications.