libnl  1.1
dsmark.c
1 /*
2  * lib/route/sch/dsmark.c DSMARK
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation version 2.1
7  * of the License.
8  *
9  * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
10  */
11 
12 /**
13  * @ingroup qdisc_api
14  * @ingroup class_api
15  * @defgroup dsmark Differentiated Services Marker (DSMARK)
16  * @{
17  */
18 
19 #include <netlink-local.h>
20 #include <netlink-tc.h>
21 #include <netlink/netlink.h>
22 #include <netlink/utils.h>
23 #include <netlink/route/qdisc.h>
24 #include <netlink/route/qdisc-modules.h>
25 #include <netlink/route/class.h>
26 #include <netlink/route/class-modules.h>
27 #include <netlink/route/sch/dsmark.h>
28 
29 /** @cond SKIP */
30 #define SCH_DSMARK_ATTR_INDICES 0x1
31 #define SCH_DSMARK_ATTR_DEFAULT_INDEX 0x2
32 #define SCH_DSMARK_ATTR_SET_TC_INDEX 0x4
33 
34 #define SCH_DSMARK_ATTR_MASK 0x1
35 #define SCH_DSMARK_ATTR_VALUE 0x2
36 /** @endcond */
37 
38 static inline struct rtnl_dsmark_qdisc *dsmark_qdisc(struct rtnl_qdisc *qdisc)
39 {
40  return (struct rtnl_dsmark_qdisc *) qdisc->q_subdata;
41 }
42 
43 static inline struct rtnl_dsmark_qdisc *
44 dsmark_qdisc_alloc(struct rtnl_qdisc *qdisc)
45 {
46  if (!qdisc->q_subdata)
47  qdisc->q_subdata = calloc(1, sizeof(struct rtnl_dsmark_qdisc));
48 
49  return dsmark_qdisc(qdisc);
50 }
51 
52 static struct nla_policy dsmark_policy[TCA_DSMARK_MAX+1] = {
53  [TCA_DSMARK_INDICES] = { .type = NLA_U16 },
54  [TCA_DSMARK_DEFAULT_INDEX] = { .type = NLA_U16 },
55  [TCA_DSMARK_SET_TC_INDEX] = { .type = NLA_FLAG },
56  [TCA_DSMARK_VALUE] = { .type = NLA_U8 },
57  [TCA_DSMARK_MASK] = { .type = NLA_U8 },
58 };
59 
60 static int dsmark_qdisc_msg_parser(struct rtnl_qdisc *qdisc)
61 {
62  int err;
63  struct nlattr *tb[TCA_DSMARK_MAX + 1];
64  struct rtnl_dsmark_qdisc *dsmark;
65 
66  err = tca_parse(tb, TCA_DSMARK_MAX, (struct rtnl_tca *) qdisc,
67  dsmark_policy);
68  if (err < 0)
69  return err;
70 
71  dsmark = dsmark_qdisc_alloc(qdisc);
72  if (!dsmark)
73  return nl_errno(ENOMEM);
74 
75  if (tb[TCA_DSMARK_INDICES]) {
76  dsmark->qdm_indices = nla_get_u16(tb[TCA_DSMARK_INDICES]);
77  dsmark->qdm_mask |= SCH_DSMARK_ATTR_INDICES;
78  }
79 
80  if (tb[TCA_DSMARK_DEFAULT_INDEX]) {
81  dsmark->qdm_default_index =
82  nla_get_u16(tb[TCA_DSMARK_DEFAULT_INDEX]);
83  dsmark->qdm_mask |= SCH_DSMARK_ATTR_DEFAULT_INDEX;
84  }
85 
86  if (tb[TCA_DSMARK_SET_TC_INDEX]) {
87  dsmark->qdm_set_tc_index = 1;
88  dsmark->qdm_mask |= SCH_DSMARK_ATTR_SET_TC_INDEX;
89  }
90 
91  return 0;
92 }
93 
94 static inline struct rtnl_dsmark_class *dsmark_class(struct rtnl_class *class)
95 {
96  return (struct rtnl_dsmark_class *) class->c_subdata;
97 }
98 
99 static inline struct rtnl_dsmark_class *
100 dsmark_class_alloc(struct rtnl_class *class)
101 {
102  if (!class->c_subdata)
103  class->c_subdata = calloc(1, sizeof(struct rtnl_dsmark_class));
104 
105  return dsmark_class(class);
106 }
107 
108 static int dsmark_class_msg_parser(struct rtnl_class *class)
109 {
110  int err;
111  struct nlattr *tb[TCA_DSMARK_MAX + 1];
112  struct rtnl_dsmark_class *dsmark;
113 
114  err = tca_parse(tb, TCA_DSMARK_MAX, (struct rtnl_tca *) class,
115  dsmark_policy);
116  if (err < 0)
117  return err;
118 
119  dsmark = dsmark_class_alloc(class);
120  if (!dsmark)
121  return nl_errno(ENOMEM);
122 
123  if (tb[TCA_DSMARK_MASK]) {
124  dsmark->cdm_bmask = nla_get_u8(tb[TCA_DSMARK_MASK]);
125  dsmark->cdm_mask |= SCH_DSMARK_ATTR_MASK;
126  }
127 
128  if (tb[TCA_DSMARK_VALUE]) {
129  dsmark->cdm_value = nla_get_u8(tb[TCA_DSMARK_VALUE]);
130  dsmark->cdm_mask |= SCH_DSMARK_ATTR_VALUE;
131  }
132 
133  return 0;
134 }
135 
136 static int dsmark_qdisc_dump_brief(struct rtnl_qdisc *qdisc,
137  struct nl_dump_params *p, int line)
138 {
139  struct rtnl_dsmark_qdisc *dsmark = dsmark_qdisc(qdisc);
140 
141  if (dsmark && (dsmark->qdm_mask & SCH_DSMARK_ATTR_INDICES))
142  dp_dump(p, " indices 0x%04x", dsmark->qdm_indices);
143 
144  return line;
145 }
146 
147 static int dsmark_qdisc_dump_full(struct rtnl_qdisc *qdisc,
148  struct nl_dump_params *p, int line)
149 {
150  struct rtnl_dsmark_qdisc *dsmark = dsmark_qdisc(qdisc);
151 
152  if (!dsmark)
153  goto ignore;
154 
155  if (dsmark->qdm_mask & SCH_DSMARK_ATTR_DEFAULT_INDEX)
156  dp_dump(p, " default index 0x%04x", dsmark->qdm_default_index);
157 
158  if (dsmark->qdm_mask & SCH_DSMARK_ATTR_SET_TC_INDEX)
159  dp_dump(p, " set-tc-index");
160 
161 ignore:
162  return line;
163 }
164 
165 static int dsmark_class_dump_brief(struct rtnl_class *class,
166  struct nl_dump_params *p, int line)
167 {
168  struct rtnl_dsmark_class *dsmark = dsmark_class(class);
169 
170  if (!dsmark)
171  goto ignore;
172 
173  if (dsmark->cdm_mask & SCH_DSMARK_ATTR_VALUE)
174  dp_dump(p, " value 0x%02x", dsmark->cdm_value);
175 
176  if (dsmark->cdm_mask & SCH_DSMARK_ATTR_MASK)
177  dp_dump(p, " mask 0x%02x", dsmark->cdm_bmask);
178 
179 ignore:
180  return line;
181 }
182 
183 static struct nl_msg *dsmark_qdisc_get_opts(struct rtnl_qdisc *qdisc)
184 {
185  struct rtnl_dsmark_qdisc *dsmark = dsmark_qdisc(qdisc);
186  struct nl_msg *msg;
187 
188  if (!dsmark)
189  return NULL;
190 
191  msg = nlmsg_alloc();
192  if (!msg)
193  goto nla_put_failure;
194 
195  if (dsmark->qdm_mask & SCH_DSMARK_ATTR_INDICES)
196  NLA_PUT_U16(msg, TCA_DSMARK_INDICES, dsmark->qdm_indices);
197 
198  if (dsmark->qdm_mask & SCH_DSMARK_ATTR_DEFAULT_INDEX)
199  NLA_PUT_U16(msg, TCA_DSMARK_DEFAULT_INDEX,
200  dsmark->qdm_default_index);
201 
202  if (dsmark->qdm_mask & SCH_DSMARK_ATTR_SET_TC_INDEX)
203  NLA_PUT_FLAG(msg, TCA_DSMARK_SET_TC_INDEX);
204 
205  return msg;
206 
207 nla_put_failure:
208  nlmsg_free(msg);
209  return NULL;
210 }
211 
212 static struct nl_msg *dsmark_class_get_opts(struct rtnl_class *class)
213 {
214  struct rtnl_dsmark_class *dsmark = dsmark_class(class);
215  struct nl_msg *msg;
216 
217  if (!dsmark)
218  return NULL;
219 
220  msg = nlmsg_alloc();
221  if (!msg)
222  goto nla_put_failure;
223 
224  if (dsmark->cdm_mask & SCH_DSMARK_ATTR_MASK)
225  NLA_PUT_U8(msg, TCA_DSMARK_MASK, dsmark->cdm_bmask);
226 
227  if (dsmark->cdm_mask & SCH_DSMARK_ATTR_VALUE)
228  NLA_PUT_U8(msg, TCA_DSMARK_VALUE, dsmark->cdm_value);
229 
230  return msg;
231 
232 nla_put_failure:
233  nlmsg_free(msg);
234  return NULL;
235 }
236 
237 /**
238  * @name Class Attribute Access
239  * @{
240  */
241 
242 /**
243  * Set bitmask of DSMARK class.
244  * @arg class DSMARK class to be modified.
245  * @arg mask New bitmask.
246  * @return 0 on success or a negative error code.
247  */
248 int rtnl_class_dsmark_set_bitmask(struct rtnl_class *class, uint8_t mask)
249 {
250  struct rtnl_dsmark_class *dsmark;
251 
252  dsmark = dsmark_class(class);
253  if (!dsmark)
254  return nl_errno(ENOMEM);
255 
256  dsmark->cdm_bmask = mask;
257  dsmark->cdm_mask |= SCH_DSMARK_ATTR_MASK;
258 
259  return 0;
260 }
261 
262 /**
263  * Get bitmask of DSMARK class.
264  * @arg class DSMARK class.
265  * @return Bitmask or a negative error code.
266  */
267 int rtnl_class_dsmark_get_bitmask(struct rtnl_class *class)
268 {
269  struct rtnl_dsmark_class *dsmark;
270 
271  dsmark = dsmark_class(class);
272  if (dsmark && dsmark->cdm_mask & SCH_DSMARK_ATTR_MASK)
273  return dsmark->cdm_bmask;
274  else
275  return nl_errno(ENOENT);
276 }
277 
278 /**
279  * Set value of DSMARK class.
280  * @arg class DSMARK class to be modified.
281  * @arg value New value.
282  * @return 0 on success or a negative errror code.
283  */
284 int rtnl_class_dsmark_set_value(struct rtnl_class *class, uint8_t value)
285 {
286  struct rtnl_dsmark_class *dsmark;
287 
288  dsmark = dsmark_class(class);
289  if (!dsmark)
290  return nl_errno(ENOMEM);
291 
292  dsmark->cdm_value = value;
293  dsmark->cdm_mask |= SCH_DSMARK_ATTR_VALUE;
294 
295  return 0;
296 }
297 
298 /**
299  * Get value of DSMARK class.
300  * @arg class DSMARK class.
301  * @return Value or a negative error code.
302  */
303 int rtnl_class_dsmark_get_value(struct rtnl_class *class)
304 {
305  struct rtnl_dsmark_class *dsmark;
306 
307  dsmark = dsmark_class(class);
308  if (dsmark && dsmark->cdm_mask & SCH_DSMARK_ATTR_VALUE)
309  return dsmark->cdm_value;
310  else
311  return nl_errno(ENOENT);
312 }
313 
314 /** @} */
315 
316 /**
317  * @name Qdisc Attribute Access
318  * @{
319  */
320 
321 /**
322  * Set indices of DSMARK qdisc.
323  * @arg qdisc DSMARK qdisc to be modified.
324  * @arg indices New indices.
325  */
326 int rtnl_qdisc_dsmark_set_indices(struct rtnl_qdisc *qdisc, uint16_t indices)
327 {
328  struct rtnl_dsmark_qdisc *dsmark;
329 
330  dsmark = dsmark_qdisc(qdisc);
331  if (!dsmark)
332  return nl_errno(ENOMEM);
333 
334  dsmark->qdm_indices = indices;
335  dsmark->qdm_mask |= SCH_DSMARK_ATTR_INDICES;
336 
337  return 0;
338 }
339 
340 /**
341  * Get indices of DSMARK qdisc.
342  * @arg qdisc DSMARK qdisc.
343  * @return Indices or a negative error code.
344  */
345 int rtnl_qdisc_dsmark_get_indices(struct rtnl_qdisc *qdisc)
346 {
347  struct rtnl_dsmark_qdisc *dsmark;
348 
349  dsmark = dsmark_qdisc(qdisc);
350  if (dsmark && dsmark->qdm_mask & SCH_DSMARK_ATTR_INDICES)
351  return dsmark->qdm_indices;
352  else
353  return nl_errno(ENOENT);
354 }
355 
356 /**
357  * Set default index of DSMARK qdisc.
358  * @arg qdisc DSMARK qdisc to be modified.
359  * @arg default_index New default index.
360  * @return 0 on success or a negative error code.
361  */
362 int rtnl_qdisc_dsmark_set_default_index(struct rtnl_qdisc *qdisc,
363  uint16_t default_index)
364 {
365  struct rtnl_dsmark_qdisc *dsmark;
366 
367  dsmark = dsmark_qdisc(qdisc);
368  if (!dsmark)
369  return nl_errno(ENOMEM);
370 
371  dsmark->qdm_default_index = default_index;
372  dsmark->qdm_mask |= SCH_DSMARK_ATTR_DEFAULT_INDEX;
373 
374  return 0;
375 }
376 
377 /**
378  * Get default index of DSMARK qdisc.
379  * @arg qdisc DSMARK qdisc.
380  * @return Default index or a negative error code.
381  */
382 int rtnl_qdisc_dsmark_get_default_index(struct rtnl_qdisc *qdisc)
383 {
384  struct rtnl_dsmark_qdisc *dsmark;
385 
386  dsmark = dsmark_qdisc(qdisc);
387  if (dsmark && dsmark->qdm_mask & SCH_DSMARK_ATTR_DEFAULT_INDEX)
388  return dsmark->qdm_default_index;
389  else
390  return nl_errno(ENOENT);
391 }
392 
393 /**
394  * Set set-tc-index flag of DSMARK qdisc.
395  * @arg qdisc DSMARK qdisc to be modified.
396  * @arg flag Flag indicating whether to enable or disable.
397  * @return 0 on success or a negative error code.
398  */
399 int rtnl_qdisc_dsmark_set_set_tc_index(struct rtnl_qdisc *qdisc, int flag)
400 {
401  struct rtnl_dsmark_qdisc *dsmark;
402 
403  dsmark = dsmark_qdisc(qdisc);
404  if (!dsmark)
405  return nl_errno(ENOMEM);
406 
407  dsmark->qdm_set_tc_index = !!flag;
408  dsmark->qdm_mask |= SCH_DSMARK_ATTR_SET_TC_INDEX;
409 
410  return 0;
411 }
412 
413 /**
414  * Get set-tc-index flag of DSMARK qdisc.
415  * @arg qdisc DSMARK qdisc to be modified.
416  * @return 1 or 0 to indicate wehther the flag is enabled or a negative
417  * error code.
418  */
419 int rtnl_qdisc_dsmark_get_set_tc_index(struct rtnl_qdisc *qdisc)
420 {
421  struct rtnl_dsmark_qdisc *dsmark;
422 
423  dsmark = dsmark_qdisc(qdisc);
424  if (dsmark && dsmark->qdm_mask & SCH_DSMARK_ATTR_SET_TC_INDEX)
425  return dsmark->qdm_set_tc_index;
426  else
427  return nl_errno(ENOENT);
428 }
429 
430 /** @} */
431 
432 static struct rtnl_qdisc_ops dsmark_qdisc_ops = {
433  .qo_kind = "dsmark",
434  .qo_msg_parser = dsmark_qdisc_msg_parser,
435  .qo_dump[NL_DUMP_BRIEF] = dsmark_qdisc_dump_brief,
436  .qo_dump[NL_DUMP_FULL] = dsmark_qdisc_dump_full,
437  .qo_get_opts = dsmark_qdisc_get_opts,
438 };
439 
440 static struct rtnl_class_ops dsmark_class_ops = {
441  .co_kind = "dsmark",
442  .co_msg_parser = dsmark_class_msg_parser,
443  .co_dump[NL_DUMP_BRIEF] = dsmark_class_dump_brief,
444  .co_get_opts = dsmark_class_get_opts,
445 };
446 
447 static void __init dsmark_init(void)
448 {
449  rtnl_qdisc_register(&dsmark_qdisc_ops);
450  rtnl_class_register(&dsmark_class_ops);
451 }
452 
453 static void __exit dsmark_exit(void)
454 {
455  rtnl_qdisc_unregister(&dsmark_qdisc_ops);
456  rtnl_class_unregister(&dsmark_class_ops);
457 }
458 
459 /** @} */