Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * Copyright 2003-2005 Devicescape Software, Inc.
3 * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
4 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/kobject.h>
12#include "ieee80211_i.h"
13#include "key.h"
14#include "debugfs.h"
15#include "debugfs_key.h"
16
17#define KEY_READ(name, prop, buflen, format_string) \
18static ssize_t key_##name##_read(struct file *file, \
19 char __user *userbuf, \
20 size_t count, loff_t *ppos) \
21{ \
22 char buf[buflen]; \
23 struct ieee80211_key *key = file->private_data; \
24 int res = scnprintf(buf, buflen, format_string, key->prop); \
25 return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
26}
27#define KEY_READ_D(name) KEY_READ(name, name, 20, "%d\n")
28#define KEY_READ_X(name) KEY_READ(name, name, 20, "0x%x\n")
29
30#define KEY_OPS(name) \
31static const struct file_operations key_ ##name## _ops = { \
32 .read = key_##name##_read, \
33 .open = mac80211_open_file_generic, \
34}
35
36#define KEY_FILE(name, format) \
37 KEY_READ_##format(name) \
38 KEY_OPS(name)
39
40#define KEY_CONF_READ(name, buflen, format_string) \
41 KEY_READ(conf_##name, conf.name, buflen, format_string)
42#define KEY_CONF_READ_D(name) KEY_CONF_READ(name, 20, "%d\n")
43
44#define KEY_CONF_OPS(name) \
45static const struct file_operations key_ ##name## _ops = { \
46 .read = key_conf_##name##_read, \
47 .open = mac80211_open_file_generic, \
48}
49
50#define KEY_CONF_FILE(name, format) \
51 KEY_CONF_READ_##format(name) \
52 KEY_CONF_OPS(name)
53
54KEY_CONF_FILE(keylen, D);
55KEY_CONF_FILE(keyidx, D);
56KEY_CONF_FILE(hw_key_idx, D);
57KEY_FILE(flags, X);
58KEY_FILE(tx_rx_count, D);
59KEY_READ(ifindex, sdata->dev->ifindex, 20, "%d\n");
60KEY_OPS(ifindex);
61
62static ssize_t key_algorithm_read(struct file *file,
63 char __user *userbuf,
64 size_t count, loff_t *ppos)
65{
66 char *alg;
67 struct ieee80211_key *key = file->private_data;
68
69 switch (key->conf.alg) {
70 case ALG_WEP:
71 alg = "WEP\n";
72 break;
73 case ALG_TKIP:
74 alg = "TKIP\n";
75 break;
76 case ALG_CCMP:
77 alg = "CCMP\n";
78 break;
79 default:
80 return 0;
81 }
82 return simple_read_from_buffer(userbuf, count, ppos, alg, strlen(alg));
83}
84KEY_OPS(algorithm);
85
86static ssize_t key_tx_spec_read(struct file *file, char __user *userbuf,
87 size_t count, loff_t *ppos)
88{
89 const u8 *tpn;
90 char buf[20];
91 int len;
92 struct ieee80211_key *key = file->private_data;
93
94 switch (key->conf.alg) {
95 case ALG_WEP:
96 len = scnprintf(buf, sizeof(buf), "\n");
97 break;
98 case ALG_TKIP:
99 len = scnprintf(buf, sizeof(buf), "%08x %04x\n",
100 key->u.tkip.tx.iv32,
101 key->u.tkip.tx.iv16);
102 break;
103 case ALG_CCMP:
104 tpn = key->u.ccmp.tx_pn;
105 len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n",
106 tpn[0], tpn[1], tpn[2], tpn[3], tpn[4], tpn[5]);
107 break;
108 default:
109 return 0;
110 }
111 return simple_read_from_buffer(userbuf, count, ppos, buf, len);
112}
113KEY_OPS(tx_spec);
114
115static ssize_t key_rx_spec_read(struct file *file, char __user *userbuf,
116 size_t count, loff_t *ppos)
117{
118 struct ieee80211_key *key = file->private_data;
119 char buf[14*NUM_RX_DATA_QUEUES+1], *p = buf;
120 int i, len;
121 const u8 *rpn;
122
123 switch (key->conf.alg) {
124 case ALG_WEP:
125 len = scnprintf(buf, sizeof(buf), "\n");
126 break;
127 case ALG_TKIP:
128 for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
129 p += scnprintf(p, sizeof(buf)+buf-p,
130 "%08x %04x\n",
131 key->u.tkip.rx[i].iv32,
132 key->u.tkip.rx[i].iv16);
133 len = p - buf;
134 break;
135 case ALG_CCMP:
136 for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
137 rpn = key->u.ccmp.rx_pn[i];
138 p += scnprintf(p, sizeof(buf)+buf-p,
139 "%02x%02x%02x%02x%02x%02x\n",
140 rpn[0], rpn[1], rpn[2],
141 rpn[3], rpn[4], rpn[5]);
142 }
143 len = p - buf;
144 break;
145 default:
146 return 0;
147 }
148 return simple_read_from_buffer(userbuf, count, ppos, buf, len);
149}
150KEY_OPS(rx_spec);
151
152static ssize_t key_replays_read(struct file *file, char __user *userbuf,
153 size_t count, loff_t *ppos)
154{
155 struct ieee80211_key *key = file->private_data;
156 char buf[20];
157 int len;
158
159 if (key->conf.alg != ALG_CCMP)
160 return 0;
161 len = scnprintf(buf, sizeof(buf), "%u\n", key->u.ccmp.replays);
162 return simple_read_from_buffer(userbuf, count, ppos, buf, len);
163}
164KEY_OPS(replays);
165
166static ssize_t key_key_read(struct file *file, char __user *userbuf,
167 size_t count, loff_t *ppos)
168{
169 struct ieee80211_key *key = file->private_data;
170 int i, res, bufsize = 2 * key->conf.keylen + 2;
171 char *buf = kmalloc(bufsize, GFP_KERNEL);
172 char *p = buf;
173
174 for (i = 0; i < key->conf.keylen; i++)
175 p += scnprintf(p, bufsize + buf - p, "%02x", key->conf.key[i]);
176 p += scnprintf(p, bufsize+buf-p, "\n");
177 res = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
178 kfree(buf);
179 return res;
180}
181KEY_OPS(key);
182
183#define DEBUGFS_ADD(name) \
184 key->debugfs.name = debugfs_create_file(#name, 0400,\
185 key->debugfs.dir, key, &key_##name##_ops);
186
187void ieee80211_debugfs_key_add(struct ieee80211_key *key)
188 {
189 static int keycount;
190 char buf[50];
191 struct sta_info *sta;
192
193 if (!key->local->debugfs.keys)
194 return;
195
196 sprintf(buf, "%d", keycount);
197 key->debugfs.cnt = keycount;
198 keycount++;
199 key->debugfs.dir = debugfs_create_dir(buf,
200 key->local->debugfs.keys);
201
202 if (!key->debugfs.dir)
203 return;
204
205 rcu_read_lock();
206 sta = rcu_dereference(key->sta);
207 if (sta)
208 sprintf(buf, "../../stations/%pM", sta->sta.addr);
209 rcu_read_unlock();
210
211 /* using sta as a boolean is fine outside RCU lock */
212 if (sta)
213 key->debugfs.stalink =
214 debugfs_create_symlink("station", key->debugfs.dir, buf);
215
216 DEBUGFS_ADD(keylen);
217 DEBUGFS_ADD(flags);
218 DEBUGFS_ADD(keyidx);
219 DEBUGFS_ADD(hw_key_idx);
220 DEBUGFS_ADD(tx_rx_count);
221 DEBUGFS_ADD(algorithm);
222 DEBUGFS_ADD(tx_spec);
223 DEBUGFS_ADD(rx_spec);
224 DEBUGFS_ADD(replays);
225 DEBUGFS_ADD(key);
226 DEBUGFS_ADD(ifindex);
227};
228
229#define DEBUGFS_DEL(name) \
230 debugfs_remove(key->debugfs.name); key->debugfs.name = NULL;
231
232void ieee80211_debugfs_key_remove(struct ieee80211_key *key)
233{
234 if (!key)
235 return;
236
237 DEBUGFS_DEL(keylen);
238 DEBUGFS_DEL(flags);
239 DEBUGFS_DEL(keyidx);
240 DEBUGFS_DEL(hw_key_idx);
241 DEBUGFS_DEL(tx_rx_count);
242 DEBUGFS_DEL(algorithm);
243 DEBUGFS_DEL(tx_spec);
244 DEBUGFS_DEL(rx_spec);
245 DEBUGFS_DEL(replays);
246 DEBUGFS_DEL(key);
247 DEBUGFS_DEL(ifindex);
248
249 debugfs_remove(key->debugfs.stalink);
250 key->debugfs.stalink = NULL;
251 debugfs_remove(key->debugfs.dir);
252 key->debugfs.dir = NULL;
253}
254void ieee80211_debugfs_key_add_default(struct ieee80211_sub_if_data *sdata)
255{
256 char buf[50];
257 struct ieee80211_key *key;
258
259 if (!sdata->debugfsdir)
260 return;
261
262 /* this is running under the key lock */
263
264 key = sdata->default_key;
265 if (key) {
266 sprintf(buf, "../keys/%d", key->debugfs.cnt);
267 sdata->common_debugfs.default_key =
268 debugfs_create_symlink("default_key",
269 sdata->debugfsdir, buf);
270 } else
271 ieee80211_debugfs_key_remove_default(sdata);
272}
273
274void ieee80211_debugfs_key_remove_default(struct ieee80211_sub_if_data *sdata)
275{
276 if (!sdata)
277 return;
278
279 debugfs_remove(sdata->common_debugfs.default_key);
280 sdata->common_debugfs.default_key = NULL;
281}
282
283void ieee80211_debugfs_key_sta_del(struct ieee80211_key *key,
284 struct sta_info *sta)
285{
286 debugfs_remove(key->debugfs.stalink);
287 key->debugfs.stalink = NULL;
288}