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) \ 18 static 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) \ 31 static 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) \ 45 static 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 54 KEY_CONF_FILE(keylen, D); 55 KEY_CONF_FILE(keyidx, D); 56 KEY_CONF_FILE(hw_key_idx, D); 57 KEY_FILE(flags, X); 58 KEY_FILE(tx_rx_count, D); 59 KEY_READ(ifindex, sdata->dev->ifindex, 20, "%d\n"); 60 KEY_OPS(ifindex); 61 62 static 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 } 84 KEY_OPS(algorithm); 85 86 static 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 } 113 KEY_OPS(tx_spec); 114 115 static 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 } 150 KEY_OPS(rx_spec); 151 152 static 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 } 164 KEY_OPS(replays); 165 166 static 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 } 181 KEY_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 187 void ieee80211_debugfs_key_add(struct ieee80211_key *key) 188 { 189 static int keycount; 190 char buf[50]; 191 DECLARE_MAC_BUF(mac); 192 struct sta_info *sta; 193 194 if (!key->local->debugfs.keys) 195 return; 196 197 sprintf(buf, "%d", keycount); 198 key->debugfs.cnt = keycount; 199 keycount++; 200 key->debugfs.dir = debugfs_create_dir(buf, 201 key->local->debugfs.keys); 202 203 if (!key->debugfs.dir) 204 return; 205 206 rcu_read_lock(); 207 sta = rcu_dereference(key->sta); 208 if (sta) 209 sprintf(buf, "../../stations/%s", 210 print_mac(mac, sta->sta.addr)); 211 rcu_read_unlock(); 212 213 /* using sta as a boolean is fine outside RCU lock */ 214 if (sta) 215 key->debugfs.stalink = 216 debugfs_create_symlink("station", key->debugfs.dir, buf); 217 218 DEBUGFS_ADD(keylen); 219 DEBUGFS_ADD(flags); 220 DEBUGFS_ADD(keyidx); 221 DEBUGFS_ADD(hw_key_idx); 222 DEBUGFS_ADD(tx_rx_count); 223 DEBUGFS_ADD(algorithm); 224 DEBUGFS_ADD(tx_spec); 225 DEBUGFS_ADD(rx_spec); 226 DEBUGFS_ADD(replays); 227 DEBUGFS_ADD(key); 228 DEBUGFS_ADD(ifindex); 229 }; 230 231 #define DEBUGFS_DEL(name) \ 232 debugfs_remove(key->debugfs.name); key->debugfs.name = NULL; 233 234 void ieee80211_debugfs_key_remove(struct ieee80211_key *key) 235 { 236 if (!key) 237 return; 238 239 DEBUGFS_DEL(keylen); 240 DEBUGFS_DEL(flags); 241 DEBUGFS_DEL(keyidx); 242 DEBUGFS_DEL(hw_key_idx); 243 DEBUGFS_DEL(tx_rx_count); 244 DEBUGFS_DEL(algorithm); 245 DEBUGFS_DEL(tx_spec); 246 DEBUGFS_DEL(rx_spec); 247 DEBUGFS_DEL(replays); 248 DEBUGFS_DEL(key); 249 DEBUGFS_DEL(ifindex); 250 251 debugfs_remove(key->debugfs.stalink); 252 key->debugfs.stalink = NULL; 253 debugfs_remove(key->debugfs.dir); 254 key->debugfs.dir = NULL; 255 } 256 void ieee80211_debugfs_key_add_default(struct ieee80211_sub_if_data *sdata) 257 { 258 char buf[50]; 259 struct ieee80211_key *key; 260 261 if (!sdata->debugfsdir) 262 return; 263 264 /* this is running under the key lock */ 265 266 key = sdata->default_key; 267 if (key) { 268 sprintf(buf, "../keys/%d", key->debugfs.cnt); 269 sdata->common_debugfs.default_key = 270 debugfs_create_symlink("default_key", 271 sdata->debugfsdir, buf); 272 } else 273 ieee80211_debugfs_key_remove_default(sdata); 274 } 275 276 void ieee80211_debugfs_key_remove_default(struct ieee80211_sub_if_data *sdata) 277 { 278 if (!sdata) 279 return; 280 281 debugfs_remove(sdata->common_debugfs.default_key); 282 sdata->common_debugfs.default_key = NULL; 283 } 284 285 void ieee80211_debugfs_key_sta_del(struct ieee80211_key *key, 286 struct sta_info *sta) 287 { 288 debugfs_remove(key->debugfs.stalink); 289 key->debugfs.stalink = NULL; 290 } 291