nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 #include <net/if.h>
2 #include <errno.h>
3 #include <string.h>
4 #include <stdio.h>
5  
6 #include <netlink/genl/genl.h>
7 #include <netlink/genl/family.h>
8 #include <netlink/genl/ctrl.h>
9 #include <netlink/msg.h>
10 #include <netlink/attr.h>
11  
12 #include <arpa/inet.h>
13  
14 #include "nl80211.h"
15 #include "iw.h"
16  
17 SECTION(coalesce);
18  
19 static int handle_coalesce_enable(struct nl80211_state *state, struct nl_cb *cb,
20 struct nl_msg *msg, int argc, char **argv,
21 enum id_input id)
22 {
23 struct nlattr *nl_rules, *nl_rule = NULL, *nl_pats, *nl_pat;
24 unsigned char *pat, *mask;
25 size_t patlen;
26 int patnum = 0, pkt_offset, err = 1;
27 char *eptr, *value1, *value2, *sptr = NULL, *end, buf[16768];
28 enum nl80211_coalesce_condition condition;
29 FILE *f = fopen(argv[0], "r");
30 enum {
31 PS_DELAY,
32 PS_CONDITION,
33 PS_PATTERNS
34 } parse_state = PS_DELAY;
35 int rule_num = 0;
36  
37 if (!f)
38 return 1;
39  
40 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
41 if (!nl_rules) {
42 fclose(f);
43 return -ENOBUFS;
44 }
45  
46 while (!feof(f)) {
47 char *eol;
48  
49 if (!fgets(buf, sizeof(buf), f))
50 break;
51  
52 eol = strchr(buf + 5, '\r');
53 if (eol)
54 *eol = 0;
55 eol = strchr(buf + 5, '\n');
56 if (eol)
57 *eol = 0;
58  
59 switch (parse_state) {
60 case PS_DELAY:
61 if (strncmp(buf, "delay=", 6) == 0) {
62 char *delay = buf + 6;
63  
64 rule_num++;
65 nl_rule = nla_nest_start(msg, rule_num);
66 if (!nl_rule)
67 goto close;
68  
69 NLA_PUT_U32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
70 strtoul(delay, &end, 10));
71 if (*end != '\0')
72 goto close;
73 parse_state = PS_CONDITION;
74 } else {
75 goto close;
76 }
77 break;
78 case PS_CONDITION:
79 if (strncmp(buf, "condition=", 10) == 0) {
80 char *cond = buf + 10;
81  
82 condition = strtoul(cond, &end, 10);
83 if (*end != '\0')
84 goto close;
85 NLA_PUT_U32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
86 condition);
87 parse_state = PS_PATTERNS;
88 } else {
89 goto close;
90 }
91 break;
92 case PS_PATTERNS:
93 if (strncmp(buf, "patterns=", 9) == 0) {
94 char *cur_pat = buf + 9;
95 char *next_pat = strchr(buf + 9, ',');
96  
97 if (next_pat) {
98 *next_pat = 0;
99 next_pat++;
100 }
101  
102 nl_pats = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
103 while (1) {
104 value1 = strtok_r(cur_pat, "+", &sptr);
105 value2 = strtok_r(NULL, "+", &sptr);
106  
107 if (!value2) {
108 pkt_offset = 0;
109 if (!value1)
110 goto close;
111 value2 = value1;
112 } else {
113 pkt_offset = strtoul(value1, &eptr, 10);
114 if (eptr != value1 + strlen(value1))
115 goto close;
116 }
117  
118 if (parse_hex_mask(value2, &pat, &patlen, &mask))
119 goto close;
120  
121 nl_pat = nla_nest_start(msg, ++patnum);
122 NLA_PUT(msg, NL80211_PKTPAT_MASK,
123 DIV_ROUND_UP(patlen, 8), mask);
124 NLA_PUT(msg, NL80211_PKTPAT_PATTERN, patlen, pat);
125 NLA_PUT_U32(msg, NL80211_PKTPAT_OFFSET,
126 pkt_offset);
127 nla_nest_end(msg, nl_pat);
128 free(mask);
129 free(pat);
130  
131 if (!next_pat)
132 break;
133 cur_pat = next_pat;
134 next_pat = strchr(cur_pat, ',');
135 if (next_pat) {
136 *next_pat = 0;
137 next_pat++;
138 }
139 }
140 nla_nest_end(msg, nl_pats);
141 nla_nest_end(msg, nl_rule);
142 parse_state = PS_DELAY;
143  
144 } else {
145 goto close;
146 }
147 break;
148 default:
149 if (buf[0] == '#')
150 continue;
151 goto close;
152 }
153 }
154  
155 if (parse_state == PS_DELAY)
156 err = 0;
157 else
158 err = 1;
159 goto close;
160 nla_put_failure:
161 err = -ENOBUFS;
162 close:
163 fclose(f);
164 nla_nest_end(msg, nl_rules);
165 return err;
166 }
167  
168 COMMAND(coalesce, enable, "<config-file>",
169 NL80211_CMD_SET_COALESCE, 0, CIB_PHY, handle_coalesce_enable,
170 "Enable coalesce with given configuration.\n"
171 "The configuration file contains coalesce rules:\n"
172 " delay=<delay>\n"
173 " condition=<condition>\n"
174 " patterns=<[offset1+]<pattern1>,<[offset2+]<pattern2>,...>\n"
175 " delay=<delay>\n"
176 " condition=<condition>\n"
177 " patterns=<[offset1+]<pattern1>,<[offset2+]<pattern2>,...>\n"
178 " ...\n"
179 "delay: maximum coalescing delay in msec.\n"
180 "condition: 1/0 i.e. 'not match'/'match' the patterns\n"
181 "patterns: each pattern is given as a bytestring with '-' in\n"
182 "places where any byte may be present, e.g. 00:11:22:-:44 will\n"
183 "match 00:11:22:33:44 and 00:11:22:33:ff:44 etc. Offset and\n"
184 "pattern should be separated by '+', e.g. 18+43:34:00:12 will\n"
185 "match '43:34:00:12' after 18 bytes of offset in Rx packet.\n");
186  
187 static int
188 handle_coalesce_disable(struct nl80211_state *state, struct nl_cb *cb,
189 struct nl_msg *msg, int argc, char **argv,
190 enum id_input id)
191 {
192 /* just a set w/o coalesce attribute */
193 return 0;
194 }
195 COMMAND(coalesce, disable, "", NL80211_CMD_SET_COALESCE, 0, CIB_PHY,
196 handle_coalesce_disable, "Disable coalesce.");
197  
198 static int print_coalesce_handler(struct nl_msg *msg, void *arg)
199 {
200 struct nlattr *attrs[NL80211_ATTR_MAX + 1];
201 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
202 struct nlattr *pattern, *rule;
203 int rem_pattern, rem_rule;
204 enum nl80211_coalesce_condition condition;
205 int delay;
206  
207 nla_parse(attrs, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
208 genlmsg_attrlen(gnlh, 0), NULL);
209  
210 if (!attrs[NL80211_ATTR_COALESCE_RULE]) {
211 printf("Coalesce is disabled.\n");
212 return NL_SKIP;
213 }
214  
215 printf("Coalesce is enabled:\n");
216  
217 nla_for_each_nested(rule, attrs[NL80211_ATTR_COALESCE_RULE], rem_rule) {
218 struct nlattr *ruleattr[NUM_NL80211_ATTR_COALESCE_RULE];
219  
220 nla_parse(ruleattr, NL80211_ATTR_COALESCE_RULE_MAX,
221 nla_data(rule), nla_len(rule), NULL);
222  
223 delay = nla_get_u32(ruleattr[NL80211_ATTR_COALESCE_RULE_DELAY]);
224 condition =
225 nla_get_u32(ruleattr[NL80211_ATTR_COALESCE_RULE_CONDITION]);
226  
227 printf("Rule - max coalescing delay: %dmsec condition:", delay);
228 if (condition)
229 printf("not match\n");
230 else
231 printf("match\n");
232  
233 if (ruleattr[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN]) {
234 nla_for_each_nested(pattern,
235 ruleattr[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
236 rem_pattern) {
237 struct nlattr *patattr[NUM_NL80211_PKTPAT];
238 int i, patlen, masklen, pkt_offset;
239 uint8_t *mask, *pat;
240  
241 nla_parse(patattr, MAX_NL80211_PKTPAT,
242 nla_data(pattern), nla_len(pattern),
243 NULL);
244 if (!patattr[NL80211_PKTPAT_MASK] ||
245 !patattr[NL80211_PKTPAT_PATTERN] ||
246 !patattr[NL80211_PKTPAT_OFFSET]) {
247 printf(" * (invalid pattern specification)\n");
248 continue;
249 }
250 masklen = nla_len(patattr[NL80211_PKTPAT_MASK]);
251 patlen = nla_len(patattr[NL80211_PKTPAT_PATTERN]);
252 pkt_offset = nla_get_u32(patattr[NL80211_PKTPAT_OFFSET]);
253 if (DIV_ROUND_UP(patlen, 8) != masklen) {
254 printf(" * (invalid pattern specification)\n");
255 continue;
256 }
257 printf(" * packet offset: %d", pkt_offset);
258 printf(" pattern: ");
259 pat = nla_data(patattr[NL80211_PKTPAT_PATTERN]);
260 mask = nla_data(patattr[NL80211_PKTPAT_MASK]);
261 for (i = 0; i < patlen; i++) {
262 if (mask[i / 8] & (1 << (i % 8)))
263 printf("%.2x", pat[i]);
264 else
265 printf("--");
266 if (i != patlen - 1)
267 printf(":");
268 }
269 printf("\n");
270 }
271 }
272 }
273  
274 return NL_SKIP;
275 }
276  
277 static int handle_coalesce_show(struct nl80211_state *state, struct nl_cb *cb,
278 struct nl_msg *msg, int argc, char **argv,
279 enum id_input id)
280 {
281 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM,
282 print_coalesce_handler, NULL);
283  
284 return 0;
285 }
286 COMMAND(coalesce, show, "", NL80211_CMD_GET_COALESCE, 0, CIB_PHY, handle_coalesce_show,
287 "Show coalesce status.");