Version 2 (modified by Ryan Izard, 11 years ago) (diff)


OpenFlow-Based Vertical Handoff over WiFi and WiMAX in the Orbit Testbed


This tutorial is designed to give insight into how OpenFlow can be used to conduct network experiments over WiMAX. As background, a vertical handoff is the (ideally seamless) migration of a network connection from one network interface to another of a different technology. An example might be your cell phone transitioning from a WiFi to a 4G connection while streaming a video. Vertical handoffs are traditionally handled by the network infrastructure, providing little-to-no control of the handoff execution at the client. Clemson University and the University of Wisconsin have partnered to develop a client-initiated and controlled vertical handoff. This project is being conducted using GENI resources -- namely Clemson's GENI WiFi and WiMAX testbeds. Development has also been done on the Orbit testbed at Rutgers, which is where this tutorial and GENI experiment will be conducted.

This tutorial will be conducted on the grid testbed at Orbit and will walk you through how to conduct an OpenFlow-based vertical handoff over WiFi and WiMAX. Three Ubuntu Linux images have been prepared for you and are available for this tutorial – (1) a client, which will initiate the handoff, (2) a server, which will serve as a correspondent node for the client, and (3) a WiFi access point (AP), which will provide a WiFi network over which the client and the server can communicate. The grid testbed at Orbit has complete WiMAX coverage via a single WiMAX base station (BS). This BS will provide the WiMAX network over which the client and the server communicate.

Let's talk specifics with repect to each Orbit node. Up first, we have the client node. The client is equipped with an Intel 6250 WiFi/WiMAX network adapter and an Atheros 5000 series WiFi network adapter. The Intel 6250 has a limitation – it can support the operation of either WiFi or WiMAX but not both simultaneously. As such, the Intel 6250 will serve as the WiMAX adapter and the Atheros 5000 series will serve as the WiFi adapter on the client. The OpenFlow-based handoff solution will choose which of these network interfaces it would like to use in order to relay messages to the server. Speaking of which, the server is equipped with the same wireless cards as the client. In order to receive packets from the client over both WiFi and WiMAX, the server will listen for the client's traffic over both its WiFi and WiMAX interfaces. To do this seamlessly, the server will also implement an OpenFlow-based solution. More details about how OpenFlow is used in both the server and the client are provided as the tutorial progresses. The third and final Orbit node necessary for this tutorial is the AP. Like the client and the server, the AP also contains both an Intel 6250 and an Atheros 5000 series wireless card; however, it will only use the Atheros card. The Atheros card on the AP is used by the software package hostapd to provide a WiFi network for both the client and the server machines. If you are interested in expanding upon this experiment, it is worth noting that Atheros cards play very well with hostapd-based networks; however, some Intel cards (such as the Intel 6250) are not directly supported. This is the reason we choose to use the Atheros over the Intel 6250 to provide the WiFi network.

Now, in order to provide a seamless handoff, the application should not be aware that the handoff takes place. The "seamlessness" of the handoff is still in development by the SDN team at Clemson. But for starters, from a networking point of view, if a network interface is brought up or is taken down, the IP address will be added to or removed from that network interface. This means the application's network socket will be broken if a break-before-make handoff occurs (which is oftentimes the case). When an application socket breaks, that means the application can no longer communicate over then network with it, and if this happens, the application must have some scheme to recreate the socket, otherwise the connection will be lost. In order to put as little reliance on the application layer as possible, a virtual tap interface is used. All applications will bind to the IP on this tap interface, and since tap interfaces are not physical, the only time it can “go down” is if we as programmers/network administrators take it down ourselves. Thus, it is a reliable way to make sure the application's socket stays “up”. In this tutorial, all application traffic will originate from and terminate at the tap interface.


  • An Orbit account. Visit for details on obtaining an account. For the tutorial at GEC18, a tutorial account will be provided for you.
  • A reservation on an Orbit testbed. Sandbox #4 (sb4) can be use for up to eight nodes. The grid testbed can support up to 400 nodes.
  • SSH access to the Orbit testbed. For this, you will need to SSH with the public key associated with your Orbit account.
  • Familiarity with networking, SSH, Linux terminal, OpenFlow, the Floodlight OpenFlow controller, Java, Bash scripting, and Python scripting
  • Familiarity with the Orbit testbed and omf commands (e.g. stat, tell, load, and save)


Where to get Help:


Tutorial Instructions

  • Part I: Design/Setup
    • Step 1: Design Experiment
    • Step 2: Establish Management Environment
    • Step 3: Obtain Resources
  • Part II: Execute
    • Step 4: Configure and Initialize Services
    • Step 5: Execute Experiment
    • Step 6: Analyze and Visualize Experiment

Attachments (4)