aboutsummaryrefslogtreecommitdiffstats
path: root/tests/hwsim/hwsim.py
blob: 23bfe32e98ca439c77794efe453fffaf633e1d55 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#
# HWSIM generic netlink controller code
# Copyright (c) 2014	Intel Corporation
#
# Author: Johannes Berg <johannes.berg@intel.com>
#
# This software may be distributed under the terms of the BSD license.
# See README for more details.

import netlink, os

# constants
HWSIM_CMD_CREATE_RADIO		= 4
HWSIM_CMD_DESTROY_RADIO		= 5

HWSIM_ATTR_CHANNELS		= 9
HWSIM_ATTR_RADIO_ID		= 10
HWSIM_ATTR_SUPPORT_P2P_DEVICE	= 14
HWSIM_ATTR_USE_CHANCTX		= 15

# the controller class
class HWSimController(object):
    def __init__(self):
        self._conn = netlink.Connection(netlink.NETLINK_GENERIC)
        self._fid = netlink.genl_controller.get_family_id('MAC80211_HWSIM')

    def create_radio(self, n_channels=None, use_chanctx=False,
                     use_p2p_device=False):
        attrs = []
        if n_channels:
            attrs.append(netlink.U32Attr(HWSIM_ATTR_CHANNELS, n_channels))
        if use_chanctx:
            attrs.append(netlink.FlagAttr(HWSIM_ATTR_USE_CHANCTX))
        if use_p2p_device:
            attrs.append(netlink.FlagAttr(HWSIM_ATTR_SUPPORT_P2P_DEVICE))

        msg = netlink.GenlMessage(self._fid, HWSIM_CMD_CREATE_RADIO,
                                  flags = netlink.NLM_F_REQUEST |
                                          netlink.NLM_F_ACK,
                                  attrs = attrs)
        return msg.send_and_recv(self._conn).ret

    def destroy_radio(self, radio_id):
        attrs = [netlink.U32Attr(HWSIM_ATTR_RADIO_ID, radio_id)]
        msg = netlink.GenlMessage(self._fid, HWSIM_CMD_DESTROY_RADIO,
                                  flags = netlink.NLM_F_REQUEST |
                                          netlink.NLM_F_ACK,
                                  attrs = attrs)
        msg.send_and_recv(self._conn)

class HWSimRadio(object):
    def __init__(self, n_channels=None, use_chanctx=False,
                 use_p2p_device=False):
        self._controller = HWSimController()
        self._n_channels = n_channels
        self._use_chanctx = use_chanctx
        self._use_p2p_dev = use_p2p_device

    def __enter__(self):
        self._radio_id = self._controller.create_radio(
              n_channels=self._n_channels,
              use_chanctx=self._use_chanctx,
              use_p2p_device=self._use_p2p_dev)
        if self._radio_id < 0:
            raise Exception("Failed to create radio (err:%d)" % self._radio_id)
        try:
            iface = os.listdir('/sys/class/mac80211_hwsim/hwsim%d/net/' % self._radio_id)[0]
        except Exception as e:
            self._controller.destroy_radio(self._radio_id)
            raise e
        return self._radio_id, iface

    def __exit__(self, type, value, traceback):
        self._controller.destroy_radio(self._radio_id)


def create(args):
    print 'Created radio %d' % c.create_radio(n_channels=args.channels,
                                              use_chanctx=args.chanctx)

def destroy(args):
    print c.destroy_radio(args.radio)

if __name__ == '__main__':
    import argparse
    c = HWSimController()

    parser = argparse.ArgumentParser(description='send hwsim control commands')
    subparsers = parser.add_subparsers(help="Commands", dest='command')
    parser_create = subparsers.add_parser('create', help='create a radio')
    parser_create.add_argument('--channels', metavar='<number_of_channels>', type=int,
                               default=0,
                               help='Number of concurrent channels supported ' +
                               'by the radio. If not specified, the number ' +
                               'of channels specified in the ' +
                               'mac80211_hwsim.channels module parameter is ' +
                               'used')
    parser_create.add_argument('--chanctx', action="store_true",
                               help='Use channel contexts, regardless of ' +
                               'whether the number of channels is 1 or ' +
                               'greater. By default channel contexts are ' +
                               'only used if the number of channels is ' +
                               'greater than 1.')
    parser_create.set_defaults(func=create)

    parser_destroy = subparsers.add_parser('destroy', help='destroy a radio')
    parser_destroy.add_argument('radio', metavar='<radio>', type=int,
                                default=0,
                                help='The number of the radio to be ' +
                                'destroyed (i.e., 0 for phy0, 1 for phy1...)')
    parser_destroy.set_defaults(func=destroy)

    args = parser.parse_args()
    args.func(args)