diff --git a/tests/bsn_ipmask.py b/tests/bsn_ipmask.py
new file mode 100644
index 0000000..cc2e893
--- /dev/null
+++ b/tests/bsn_ipmask.py
@@ -0,0 +1,195 @@
+"""
+"""
+import struct
+
+import logging
+
+import oftest.controller as controller
+import oftest.cstruct as ofp
+import oftest.message as message
+import basic
+
+from testutils import *
+
+#@var port_map Local copy of the configuration map from OF port
+# numbers to OS interfaces
+im_port_map = None
+#@var im_logger Local logger object
+im_logger = None
+#@var im_config Local copy of global configuration data
+im_config = None
+
+# For test priority
+#@var test_prio Set test priority for local tests
+test_prio = {}
+
+def test_set_init(config):
+    basic.test_set_init(config)
+
+    global im_port_map
+    global im_logger
+    global im_config
+
+    im_logger = logging.getLogger("ipmask")
+    im_logger.info("Initializing test set")
+    im_port_map = config["port_map"]
+    im_config = config
+
+def normal_ip_mask(index):
+    """
+    Return the IP mask for the given wildcard index 0 - 63 per the OF 1.0 spec
+    """
+    if index < 32:
+        return ((1 << 32) - 1) ^ ((1 << index) - 1)
+    else:
+        return 0
+
+def fancy_ip_mask(index):
+    """
+    Return the IP mask for the given wildcard index 0 - 31 per the OF 1.0 spec.
+    For wildcard index 32 - 63, return a "negative" IP mask:
+      32 : wildcard the first bit, mask 127.255.255.255
+      33 : wildcard all first 2 bits, mask 63.255.255.255
+      ...
+      62 : wildcard all but last bit, mask 0.0.0.1
+      63 : wildcard all bits, mask 0.0.0.0
+    """
+    if index < 32:
+        return ((1 << 32) - 1) ^ ((1 << index) - 1)
+    else:
+        return (1 << (63 - index)) - 1
+
+class BSNConfigIPMask(basic.SimpleDataPlane):
+    """
+    Exercise BSN vendor extension for configuring IP source/dest match mask
+    """
+    def bsn_set_ip_mask(self, index, mask):
+        """
+        Use the BSN_SET_IP_MASK vendor command to change the IP mask for the
+        given wildcard index
+        """
+        m = message.vendor()
+        m.vendor = 0x005c16c7
+        m.data = struct.pack("!LBBBBL", 0, index, 0, 0, 0, mask)
+        rc = self.controller.message_send(m)
+        self.assertNotEqual(rc, -1, "Error sending set IP mask command")
+
+    def bsn_get_ip_mask(self, index):
+        """
+        Use the BSN_GET_IP_MASK vendor command to get the current IP mask for
+        the given wildcard index
+        """
+        m = message.vendor()
+        m.vendor = 0x005c16c7
+        m.data = struct.pack( "!LBBBBL", 1, index, 0, 0, 0, 0 )
+        rc = self.controller.message_send(m)
+        self.assertNotEqual(rc, -1, "Error sending get IP mask command")
+        m, r = self.controller.poll(ofp.OFPT_VENDOR, 2)
+        self.assertEqual(m.vendor, 0x005c16c7, "Wrong vendor ID")
+        x = struct.unpack("!LBBBBL", m.data)
+        self.assertEqual(x[0], 1, "Wrong subtype")
+        self.assertEqual(x[1], index, "Wrong index")
+        return x[5]
+
+    def runTest(self):
+        for index in range(0, 64):
+            mask = self.bsn_get_ip_mask(index)
+            im_logger.info("Index %d mask is %s" %
+                           (index, scapy.utils.ltoa(mask)))
+            self.assertEqual(mask, normal_ip_mask(index), "Unexpected IP mask")
+
+        for index in range(0, 64):
+            mask = normal_ip_mask(index)
+            if mask == 0:
+                im_logger.info("Skipping IP wildcard index %d" % index)
+            else:
+                im_logger.info("Testing IP wildcard index %d" % index)
+                self.check_ip_mask(True, index, mask)
+                self.check_ip_mask(False, index, mask)
+
+        im_logger.info("Setting fancy IP masks")
+        for index in range(0, 64):
+            self.bsn_set_ip_mask(index, fancy_ip_mask(index))
+        for index in range(0, 64):
+            mask = self.bsn_get_ip_mask(index)
+            im_logger.info("Index %d mask is %s" %
+                           (index, scapy.utils.ltoa(mask)))
+            self.assertEqual(mask, fancy_ip_mask(index), "Unexpected IP mask")
+
+        for index in range(0, 64):
+            mask = fancy_ip_mask(index)
+            if mask == 0:
+                im_logger.info("Skipping IP wildcard index %d" % index)
+            else:
+                im_logger.info("Testing IP wildcard index %d" % index)
+                self.check_ip_mask(True, index, mask)
+                self.check_ip_mask(False, index, mask)
+
+    def check_ip_mask(self, source, index, mask):
+        ports = im_port_map.keys()
+
+        # For each mask we install two flow entries, one which matches
+        # on IP source or dest addr all-0s (modulo the mask) and
+        # outputs to port 1, the other which matches on all-1s (modulo
+        # the mask) and outputs to port 2.
+
+        # Then we construct four packets: The first two are the same
+        # as the two flow entry matches (all 0s and all 1s), and we
+        # check that the packets go to ports 1 and 2, respectively.
+        # For the second set of packets, we flip the un-masked bits
+        # and check that only the masked bits are matched.
+
+        ip0 = scapy.utils.ltoa(0x00000000)
+        ip1 = scapy.utils.ltoa(0xffffffff)
+        ip2 = scapy.utils.ltoa(0xffffffff ^ mask)
+        ip3 = scapy.utils.ltoa(0x00000000 ^ mask)
+
+        if source:
+           wildcards = ((ofp.OFPFW_ALL ^ ofp.OFPFW_DL_TYPE ^ ofp.OFPFW_NW_SRC_MASK)
+                        | (index << ofp.OFPFW_NW_SRC_SHIFT))
+           pkt0 = simple_tcp_packet(ip_src=ip0)
+           pkt1 = simple_tcp_packet(ip_src=ip1)
+           pkt2 = simple_tcp_packet(ip_src=ip2)
+           pkt3 = simple_tcp_packet(ip_src=ip3)
+           msg = lambda ip: im_logger.info("Testing source IP %s" % ip)
+        else:
+           wildcards = ((ofp.OFPFW_ALL ^ ofp.OFPFW_DL_TYPE ^ ofp.OFPFW_NW_DST_MASK)
+                        | (index << ofp.OFPFW_NW_DST_SHIFT))
+           pkt0 = simple_tcp_packet(ip_dst=ip0)
+           pkt1 = simple_tcp_packet(ip_dst=ip1)
+           pkt2 = simple_tcp_packet(ip_dst=ip2)
+           pkt3 = simple_tcp_packet(ip_dst=ip3)
+           msg = lambda ip: im_logger.info("Testing dest IP %s" % ip)
+
+        rc = delete_all_flows(self.controller, im_logger)
+        self.assertEqual(rc, 0, "Failed to delete all flows")
+
+        rc = self.controller.message_send(flow_msg_create(
+              self, pkt0, ing_port=ports[0], egr_ports=[ports[1]],
+              wildcards=wildcards))
+        self.assertNotEqual(rc, -1, "Error inserting flow entry 0")
+        rc = self.controller.message_send(flow_msg_create(
+              self, pkt1, ing_port=ports[0], egr_ports=[ports[2]],
+              wildcards=wildcards))
+        self.assertNotEqual(rc, -1, "Error inserting flow entry 1")
+
+        self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+            
+        msg(ip0)
+        self.dataplane.send(ports[0], str(pkt0))
+        receive_pkt_verify(self, [ports[1]], pkt0, ports[0])
+
+        msg(ip1)
+        self.dataplane.send(ports[0], str(pkt1))
+        receive_pkt_verify(self, [ports[2]], pkt1, ports[0])
+
+        msg(ip2)
+        self.dataplane.send(ports[0], str(pkt2))
+        receive_pkt_verify(self, [ports[1]], pkt2, ports[0])
+
+        msg(ip3)
+        self.dataplane.send(ports[0], str(pkt3))
+        receive_pkt_verify(self, [ports[2]], pkt3, ports[0])
+
+# Don't run by default
+test_prio["BSNConfigIPMask"] = -1