2 * Copyright (c) 2014, Ericsson AB
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the names of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * Alternatively, this software may be distributed under the terms of the
18 * GNU General Public License ("GPL") version 2 as published by the Free
19 * Software Foundation.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
37 #include "name_table.h"
41 #include <net/genetlink.h>
42 #include <linux/tipc_config.h>
44 /* The legacy API had an artificial message length limit called
45 * ULTRA_STRING_MAX_LEN.
47 #define ULTRA_STRING_MAX_LEN 32768
49 #define TIPC_SKB_MAX TLV_SPACE(ULTRA_STRING_MAX_LEN)
51 #define REPLY_TRUNCATED "<truncated>\n"
53 struct tipc_nl_compat_msg
{
64 struct tipc_nl_compat_cmd_dump
{
65 int (*header
)(struct tipc_nl_compat_msg
*);
66 int (*dumpit
)(struct sk_buff
*, struct netlink_callback
*);
67 int (*format
)(struct tipc_nl_compat_msg
*msg
, struct nlattr
**attrs
);
70 struct tipc_nl_compat_cmd_doit
{
71 int (*doit
)(struct sk_buff
*skb
, struct genl_info
*info
);
72 int (*transcode
)(struct tipc_nl_compat_cmd_doit
*cmd
,
73 struct sk_buff
*skb
, struct tipc_nl_compat_msg
*msg
);
76 static int tipc_skb_tailroom(struct sk_buff
*skb
)
81 tailroom
= skb_tailroom(skb
);
82 limit
= TIPC_SKB_MAX
- skb
->len
;
90 static int tipc_add_tlv(struct sk_buff
*skb
, u16 type
, void *data
, u16 len
)
92 struct tlv_desc
*tlv
= (struct tlv_desc
*)skb_tail_pointer(skb
);
94 if (tipc_skb_tailroom(skb
) < TLV_SPACE(len
))
97 skb_put(skb
, TLV_SPACE(len
));
98 tlv
->tlv_type
= htons(type
);
99 tlv
->tlv_len
= htons(TLV_LENGTH(len
));
101 memcpy(TLV_DATA(tlv
), data
, len
);
106 static void tipc_tlv_init(struct sk_buff
*skb
, u16 type
)
108 struct tlv_desc
*tlv
= (struct tlv_desc
*)skb
->data
;
111 TLV_SET_TYPE(tlv
, type
);
112 skb_put(skb
, sizeof(struct tlv_desc
));
115 static int tipc_tlv_sprintf(struct sk_buff
*skb
, const char *fmt
, ...)
121 struct tlv_desc
*tlv
;
124 rem
= tipc_skb_tailroom(skb
);
126 tlv
= (struct tlv_desc
*)skb
->data
;
127 len
= TLV_GET_LEN(tlv
);
128 buf
= TLV_DATA(tlv
) + len
;
131 n
= vscnprintf(buf
, rem
, fmt
, args
);
134 TLV_SET_LEN(tlv
, n
+ len
);
140 static struct sk_buff
*tipc_tlv_alloc(int size
)
145 size
= TLV_SPACE(size
);
146 hdr_len
= nlmsg_total_size(GENL_HDRLEN
+ TIPC_GENL_HDRLEN
);
148 buf
= alloc_skb(hdr_len
+ size
, GFP_KERNEL
);
152 skb_reserve(buf
, hdr_len
);
157 static struct sk_buff
*tipc_get_err_tlv(char *str
)
159 int str_len
= strlen(str
) + 1;
162 buf
= tipc_tlv_alloc(TLV_SPACE(str_len
));
164 tipc_add_tlv(buf
, TIPC_TLV_ERROR_STRING
, str
, str_len
);
169 static int __tipc_nl_compat_dumpit(struct tipc_nl_compat_cmd_dump
*cmd
,
170 struct tipc_nl_compat_msg
*msg
,
176 struct nlmsghdr
*nlmsg
;
177 struct netlink_callback cb
;
179 memset(&cb
, 0, sizeof(cb
));
180 cb
.nlh
= (struct nlmsghdr
*)arg
->data
;
183 buf
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
187 buf
->sk
= msg
->dst_sk
;
192 len
= (*cmd
->dumpit
)(buf
, &cb
);
194 nlmsg_for_each_msg(nlmsg
, nlmsg_hdr(buf
), len
, rem
) {
195 struct nlattr
**attrs
;
197 err
= tipc_nlmsg_parse(nlmsg
, &attrs
);
201 err
= (*cmd
->format
)(msg
, attrs
);
205 if (tipc_skb_tailroom(msg
->rep
) <= 1) {
211 skb_reset_tail_pointer(buf
);
221 if (err
== -EMSGSIZE
) {
222 /* The legacy API only considered messages filling
223 * "ULTRA_STRING_MAX_LEN" to be truncated.
225 if ((TIPC_SKB_MAX
- msg
->rep
->len
) <= 1) {
226 char *tail
= skb_tail_pointer(msg
->rep
);
229 sprintf(tail
- sizeof(REPLY_TRUNCATED
) - 1,
239 static int tipc_nl_compat_dumpit(struct tipc_nl_compat_cmd_dump
*cmd
,
240 struct tipc_nl_compat_msg
*msg
)
245 if (msg
->req_type
&& !TLV_CHECK_TYPE(msg
->req
, msg
->req_type
))
248 msg
->rep
= tipc_tlv_alloc(msg
->rep_size
);
253 tipc_tlv_init(msg
->rep
, msg
->rep_type
);
258 arg
= nlmsg_new(0, GFP_KERNEL
);
264 err
= __tipc_nl_compat_dumpit(cmd
, msg
, arg
);
273 static int __tipc_nl_compat_doit(struct tipc_nl_compat_cmd_doit
*cmd
,
274 struct tipc_nl_compat_msg
*msg
)
277 struct sk_buff
*doit_buf
;
278 struct sk_buff
*trans_buf
;
279 struct nlattr
**attrbuf
;
280 struct genl_info info
;
282 trans_buf
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
286 err
= (*cmd
->transcode
)(cmd
, trans_buf
, msg
);
290 attrbuf
= kmalloc((tipc_genl_family
.maxattr
+ 1) *
291 sizeof(struct nlattr
*), GFP_KERNEL
);
297 err
= nla_parse(attrbuf
, tipc_genl_family
.maxattr
,
298 (const struct nlattr
*)trans_buf
->data
,
299 trans_buf
->len
, NULL
);
303 doit_buf
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
309 doit_buf
->sk
= msg
->dst_sk
;
311 memset(&info
, 0, sizeof(info
));
312 info
.attrs
= attrbuf
;
314 err
= (*cmd
->doit
)(doit_buf
, &info
);
320 kfree_skb(trans_buf
);
325 static int tipc_nl_compat_doit(struct tipc_nl_compat_cmd_doit
*cmd
,
326 struct tipc_nl_compat_msg
*msg
)
330 if (msg
->req_type
&& !TLV_CHECK_TYPE(msg
->req
, msg
->req_type
))
333 err
= __tipc_nl_compat_doit(cmd
, msg
);
337 /* The legacy API considered an empty message a success message */
338 msg
->rep
= tipc_tlv_alloc(0);
345 static int tipc_nl_compat_bearer_dump(struct tipc_nl_compat_msg
*msg
,
346 struct nlattr
**attrs
)
348 struct nlattr
*bearer
[TIPC_NLA_BEARER_MAX
+ 1];
351 if (!attrs
[TIPC_NLA_BEARER
])
354 err
= nla_parse_nested(bearer
, TIPC_NLA_BEARER_MAX
,
355 attrs
[TIPC_NLA_BEARER
], NULL
);
359 return tipc_add_tlv(msg
->rep
, TIPC_TLV_BEARER_NAME
,
360 nla_data(bearer
[TIPC_NLA_BEARER_NAME
]),
361 nla_len(bearer
[TIPC_NLA_BEARER_NAME
]));
364 static int tipc_nl_compat_bearer_enable(struct tipc_nl_compat_cmd_doit
*cmd
,
366 struct tipc_nl_compat_msg
*msg
)
369 struct nlattr
*bearer
;
370 struct tipc_bearer_config
*b
;
372 b
= (struct tipc_bearer_config
*)TLV_DATA(msg
->req
);
374 bearer
= nla_nest_start(skb
, TIPC_NLA_BEARER
);
378 if (nla_put_string(skb
, TIPC_NLA_BEARER_NAME
, b
->name
))
381 if (nla_put_u32(skb
, TIPC_NLA_BEARER_DOMAIN
, ntohl(b
->disc_domain
)))
384 if (ntohl(b
->priority
) <= TIPC_MAX_LINK_PRI
) {
385 prop
= nla_nest_start(skb
, TIPC_NLA_BEARER_PROP
);
388 if (nla_put_u32(skb
, TIPC_NLA_PROP_PRIO
, ntohl(b
->priority
)))
390 nla_nest_end(skb
, prop
);
392 nla_nest_end(skb
, bearer
);
397 static int tipc_nl_compat_bearer_disable(struct tipc_nl_compat_cmd_doit
*cmd
,
399 struct tipc_nl_compat_msg
*msg
)
402 struct nlattr
*bearer
;
404 name
= (char *)TLV_DATA(msg
->req
);
406 bearer
= nla_nest_start(skb
, TIPC_NLA_BEARER
);
410 if (nla_put_string(skb
, TIPC_NLA_BEARER_NAME
, name
))
413 nla_nest_end(skb
, bearer
);
418 static inline u32
perc(u32 count
, u32 total
)
420 return (count
* 100 + (total
/ 2)) / total
;
423 static void __fill_bc_link_stat(struct tipc_nl_compat_msg
*msg
,
424 struct nlattr
*prop
[], struct nlattr
*stats
[])
426 tipc_tlv_sprintf(msg
->rep
, " Window:%u packets\n",
427 nla_get_u32(prop
[TIPC_NLA_PROP_WIN
]));
429 tipc_tlv_sprintf(msg
->rep
,
430 " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
431 nla_get_u32(stats
[TIPC_NLA_STATS_RX_INFO
]),
432 nla_get_u32(stats
[TIPC_NLA_STATS_RX_FRAGMENTS
]),
433 nla_get_u32(stats
[TIPC_NLA_STATS_RX_FRAGMENTED
]),
434 nla_get_u32(stats
[TIPC_NLA_STATS_RX_BUNDLES
]),
435 nla_get_u32(stats
[TIPC_NLA_STATS_RX_BUNDLED
]));
437 tipc_tlv_sprintf(msg
->rep
,
438 " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
439 nla_get_u32(stats
[TIPC_NLA_STATS_TX_INFO
]),
440 nla_get_u32(stats
[TIPC_NLA_STATS_TX_FRAGMENTS
]),
441 nla_get_u32(stats
[TIPC_NLA_STATS_TX_FRAGMENTED
]),
442 nla_get_u32(stats
[TIPC_NLA_STATS_TX_BUNDLES
]),
443 nla_get_u32(stats
[TIPC_NLA_STATS_TX_BUNDLED
]));
445 tipc_tlv_sprintf(msg
->rep
, " RX naks:%u defs:%u dups:%u\n",
446 nla_get_u32(stats
[TIPC_NLA_STATS_RX_NACKS
]),
447 nla_get_u32(stats
[TIPC_NLA_STATS_RX_DEFERRED
]),
448 nla_get_u32(stats
[TIPC_NLA_STATS_DUPLICATES
]));
450 tipc_tlv_sprintf(msg
->rep
, " TX naks:%u acks:%u dups:%u\n",
451 nla_get_u32(stats
[TIPC_NLA_STATS_TX_NACKS
]),
452 nla_get_u32(stats
[TIPC_NLA_STATS_TX_ACKS
]),
453 nla_get_u32(stats
[TIPC_NLA_STATS_RETRANSMITTED
]));
455 tipc_tlv_sprintf(msg
->rep
,
456 " Congestion link:%u Send queue max:%u avg:%u",
457 nla_get_u32(stats
[TIPC_NLA_STATS_LINK_CONGS
]),
458 nla_get_u32(stats
[TIPC_NLA_STATS_MAX_QUEUE
]),
459 nla_get_u32(stats
[TIPC_NLA_STATS_AVG_QUEUE
]));
462 static int tipc_nl_compat_link_stat_dump(struct tipc_nl_compat_msg
*msg
,
463 struct nlattr
**attrs
)
466 struct nlattr
*link
[TIPC_NLA_LINK_MAX
+ 1];
467 struct nlattr
*prop
[TIPC_NLA_PROP_MAX
+ 1];
468 struct nlattr
*stats
[TIPC_NLA_STATS_MAX
+ 1];
471 if (!attrs
[TIPC_NLA_LINK
])
474 err
= nla_parse_nested(link
, TIPC_NLA_LINK_MAX
, attrs
[TIPC_NLA_LINK
],
479 if (!link
[TIPC_NLA_LINK_PROP
])
482 err
= nla_parse_nested(prop
, TIPC_NLA_PROP_MAX
,
483 link
[TIPC_NLA_LINK_PROP
], NULL
);
487 if (!link
[TIPC_NLA_LINK_STATS
])
490 err
= nla_parse_nested(stats
, TIPC_NLA_STATS_MAX
,
491 link
[TIPC_NLA_LINK_STATS
], NULL
);
495 name
= (char *)TLV_DATA(msg
->req
);
496 if (strcmp(name
, nla_data(link
[TIPC_NLA_LINK_NAME
])) != 0)
499 tipc_tlv_sprintf(msg
->rep
, "\nLink <%s>\n",
500 nla_data(link
[TIPC_NLA_LINK_NAME
]));
502 if (link
[TIPC_NLA_LINK_BROADCAST
]) {
503 __fill_bc_link_stat(msg
, prop
, stats
);
507 if (link
[TIPC_NLA_LINK_ACTIVE
])
508 tipc_tlv_sprintf(msg
->rep
, " ACTIVE");
509 else if (link
[TIPC_NLA_LINK_UP
])
510 tipc_tlv_sprintf(msg
->rep
, " STANDBY");
512 tipc_tlv_sprintf(msg
->rep
, " DEFUNCT");
514 tipc_tlv_sprintf(msg
->rep
, " MTU:%u Priority:%u",
515 nla_get_u32(link
[TIPC_NLA_LINK_MTU
]),
516 nla_get_u32(prop
[TIPC_NLA_PROP_PRIO
]));
518 tipc_tlv_sprintf(msg
->rep
, " Tolerance:%u ms Window:%u packets\n",
519 nla_get_u32(prop
[TIPC_NLA_PROP_TOL
]),
520 nla_get_u32(prop
[TIPC_NLA_PROP_WIN
]));
522 tipc_tlv_sprintf(msg
->rep
,
523 " RX packets:%u fragments:%u/%u bundles:%u/%u\n",
524 nla_get_u32(link
[TIPC_NLA_LINK_RX
]) -
525 nla_get_u32(stats
[TIPC_NLA_STATS_RX_INFO
]),
526 nla_get_u32(stats
[TIPC_NLA_STATS_RX_FRAGMENTS
]),
527 nla_get_u32(stats
[TIPC_NLA_STATS_RX_FRAGMENTED
]),
528 nla_get_u32(stats
[TIPC_NLA_STATS_RX_BUNDLES
]),
529 nla_get_u32(stats
[TIPC_NLA_STATS_RX_BUNDLED
]));
531 tipc_tlv_sprintf(msg
->rep
,
532 " TX packets:%u fragments:%u/%u bundles:%u/%u\n",
533 nla_get_u32(link
[TIPC_NLA_LINK_TX
]) -
534 nla_get_u32(stats
[TIPC_NLA_STATS_TX_INFO
]),
535 nla_get_u32(stats
[TIPC_NLA_STATS_TX_FRAGMENTS
]),
536 nla_get_u32(stats
[TIPC_NLA_STATS_TX_FRAGMENTED
]),
537 nla_get_u32(stats
[TIPC_NLA_STATS_TX_BUNDLES
]),
538 nla_get_u32(stats
[TIPC_NLA_STATS_TX_BUNDLED
]));
540 tipc_tlv_sprintf(msg
->rep
,
541 " TX profile sample:%u packets average:%u octets\n",
542 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_CNT
]),
543 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_TOT
]) /
544 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
]));
546 tipc_tlv_sprintf(msg
->rep
,
547 " 0-64:%u%% -256:%u%% -1024:%u%% -4096:%u%% ",
548 perc(nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_P0
]),
549 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
])),
550 perc(nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_P1
]),
551 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
])),
552 perc(nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_P2
]),
553 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
])),
554 perc(nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_P3
]),
555 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
])));
557 tipc_tlv_sprintf(msg
->rep
, "-16384:%u%% -32768:%u%% -66000:%u%%\n",
558 perc(nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_P4
]),
559 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
])),
560 perc(nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_P5
]),
561 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
])),
562 perc(nla_get_u32(stats
[TIPC_NLA_STATS_MSG_LEN_P6
]),
563 nla_get_u32(stats
[TIPC_NLA_STATS_MSG_PROF_TOT
])));
565 tipc_tlv_sprintf(msg
->rep
,
566 " RX states:%u probes:%u naks:%u defs:%u dups:%u\n",
567 nla_get_u32(stats
[TIPC_NLA_STATS_RX_STATES
]),
568 nla_get_u32(stats
[TIPC_NLA_STATS_RX_PROBES
]),
569 nla_get_u32(stats
[TIPC_NLA_STATS_RX_NACKS
]),
570 nla_get_u32(stats
[TIPC_NLA_STATS_RX_DEFERRED
]),
571 nla_get_u32(stats
[TIPC_NLA_STATS_DUPLICATES
]));
573 tipc_tlv_sprintf(msg
->rep
,
574 " TX states:%u probes:%u naks:%u acks:%u dups:%u\n",
575 nla_get_u32(stats
[TIPC_NLA_STATS_TX_STATES
]),
576 nla_get_u32(stats
[TIPC_NLA_STATS_TX_PROBES
]),
577 nla_get_u32(stats
[TIPC_NLA_STATS_TX_NACKS
]),
578 nla_get_u32(stats
[TIPC_NLA_STATS_TX_ACKS
]),
579 nla_get_u32(stats
[TIPC_NLA_STATS_RETRANSMITTED
]));
581 tipc_tlv_sprintf(msg
->rep
,
582 " Congestion link:%u Send queue max:%u avg:%u",
583 nla_get_u32(stats
[TIPC_NLA_STATS_LINK_CONGS
]),
584 nla_get_u32(stats
[TIPC_NLA_STATS_MAX_QUEUE
]),
585 nla_get_u32(stats
[TIPC_NLA_STATS_AVG_QUEUE
]));
590 static int tipc_nl_compat_link_dump(struct tipc_nl_compat_msg
*msg
,
591 struct nlattr
**attrs
)
593 struct nlattr
*link
[TIPC_NLA_LINK_MAX
+ 1];
594 struct tipc_link_info link_info
;
597 if (!attrs
[TIPC_NLA_LINK
])
600 err
= nla_parse_nested(link
, TIPC_NLA_LINK_MAX
, attrs
[TIPC_NLA_LINK
],
605 link_info
.dest
= nla_get_flag(link
[TIPC_NLA_LINK_DEST
]);
606 link_info
.up
= htonl(nla_get_flag(link
[TIPC_NLA_LINK_UP
]));
607 strcpy(link_info
.str
, nla_data(link
[TIPC_NLA_LINK_NAME
]));
609 return tipc_add_tlv(msg
->rep
, TIPC_TLV_LINK_INFO
,
610 &link_info
, sizeof(link_info
));
613 static int __tipc_add_link_prop(struct sk_buff
*skb
,
614 struct tipc_nl_compat_msg
*msg
,
615 struct tipc_link_config
*lc
)
618 case TIPC_CMD_SET_LINK_PRI
:
619 return nla_put_u32(skb
, TIPC_NLA_PROP_PRIO
, ntohl(lc
->value
));
620 case TIPC_CMD_SET_LINK_TOL
:
621 return nla_put_u32(skb
, TIPC_NLA_PROP_TOL
, ntohl(lc
->value
));
622 case TIPC_CMD_SET_LINK_WINDOW
:
623 return nla_put_u32(skb
, TIPC_NLA_PROP_WIN
, ntohl(lc
->value
));
629 static int tipc_nl_compat_media_set(struct sk_buff
*skb
,
630 struct tipc_nl_compat_msg
*msg
)
633 struct nlattr
*media
;
634 struct tipc_link_config
*lc
;
636 lc
= (struct tipc_link_config
*)TLV_DATA(msg
->req
);
638 media
= nla_nest_start(skb
, TIPC_NLA_MEDIA
);
642 if (nla_put_string(skb
, TIPC_NLA_MEDIA_NAME
, lc
->name
))
645 prop
= nla_nest_start(skb
, TIPC_NLA_MEDIA_PROP
);
649 __tipc_add_link_prop(skb
, msg
, lc
);
650 nla_nest_end(skb
, prop
);
651 nla_nest_end(skb
, media
);
656 static int tipc_nl_compat_bearer_set(struct sk_buff
*skb
,
657 struct tipc_nl_compat_msg
*msg
)
660 struct nlattr
*bearer
;
661 struct tipc_link_config
*lc
;
663 lc
= (struct tipc_link_config
*)TLV_DATA(msg
->req
);
665 bearer
= nla_nest_start(skb
, TIPC_NLA_BEARER
);
669 if (nla_put_string(skb
, TIPC_NLA_BEARER_NAME
, lc
->name
))
672 prop
= nla_nest_start(skb
, TIPC_NLA_BEARER_PROP
);
676 __tipc_add_link_prop(skb
, msg
, lc
);
677 nla_nest_end(skb
, prop
);
678 nla_nest_end(skb
, bearer
);
683 static int __tipc_nl_compat_link_set(struct sk_buff
*skb
,
684 struct tipc_nl_compat_msg
*msg
)
688 struct tipc_link_config
*lc
;
690 lc
= (struct tipc_link_config
*)TLV_DATA(msg
->req
);
692 link
= nla_nest_start(skb
, TIPC_NLA_LINK
);
696 if (nla_put_string(skb
, TIPC_NLA_LINK_NAME
, lc
->name
))
699 prop
= nla_nest_start(skb
, TIPC_NLA_LINK_PROP
);
703 __tipc_add_link_prop(skb
, msg
, lc
);
704 nla_nest_end(skb
, prop
);
705 nla_nest_end(skb
, link
);
710 static int tipc_nl_compat_link_set(struct tipc_nl_compat_cmd_doit
*cmd
,
712 struct tipc_nl_compat_msg
*msg
)
714 struct tipc_link_config
*lc
;
715 struct tipc_bearer
*bearer
;
716 struct tipc_media
*media
;
718 lc
= (struct tipc_link_config
*)TLV_DATA(msg
->req
);
720 media
= tipc_media_find(lc
->name
);
722 cmd
->doit
= &tipc_nl_media_set
;
723 return tipc_nl_compat_media_set(skb
, msg
);
726 bearer
= tipc_bearer_find(msg
->net
, lc
->name
);
728 cmd
->doit
= &tipc_nl_bearer_set
;
729 return tipc_nl_compat_bearer_set(skb
, msg
);
732 return __tipc_nl_compat_link_set(skb
, msg
);
735 static int tipc_nl_compat_link_reset_stats(struct tipc_nl_compat_cmd_doit
*cmd
,
737 struct tipc_nl_compat_msg
*msg
)
742 name
= (char *)TLV_DATA(msg
->req
);
744 link
= nla_nest_start(skb
, TIPC_NLA_LINK
);
748 if (nla_put_string(skb
, TIPC_NLA_LINK_NAME
, name
))
751 nla_nest_end(skb
, link
);
756 static int tipc_nl_compat_name_table_dump_header(struct tipc_nl_compat_msg
*msg
)
760 struct tipc_name_table_query
*ntq
;
761 static const char * const header
[] = {
768 ntq
= (struct tipc_name_table_query
*)TLV_DATA(msg
->req
);
770 depth
= ntohl(ntq
->depth
);
774 for (i
= 0; i
< depth
; i
++)
775 tipc_tlv_sprintf(msg
->rep
, header
[i
]);
776 tipc_tlv_sprintf(msg
->rep
, "\n");
781 static int tipc_nl_compat_name_table_dump(struct tipc_nl_compat_msg
*msg
,
782 struct nlattr
**attrs
)
785 struct tipc_name_table_query
*ntq
;
786 struct nlattr
*nt
[TIPC_NLA_NAME_TABLE_MAX
+ 1];
787 struct nlattr
*publ
[TIPC_NLA_PUBL_MAX
+ 1];
788 u32 node
, depth
, type
, lowbound
, upbound
;
789 static const char * const scope_str
[] = {"", " zone", " cluster",
793 if (!attrs
[TIPC_NLA_NAME_TABLE
])
796 err
= nla_parse_nested(nt
, TIPC_NLA_NAME_TABLE_MAX
,
797 attrs
[TIPC_NLA_NAME_TABLE
], NULL
);
801 if (!nt
[TIPC_NLA_NAME_TABLE_PUBL
])
804 err
= nla_parse_nested(publ
, TIPC_NLA_PUBL_MAX
,
805 nt
[TIPC_NLA_NAME_TABLE_PUBL
], NULL
);
809 ntq
= (struct tipc_name_table_query
*)TLV_DATA(msg
->req
);
811 depth
= ntohl(ntq
->depth
);
812 type
= ntohl(ntq
->type
);
813 lowbound
= ntohl(ntq
->lowbound
);
814 upbound
= ntohl(ntq
->upbound
);
816 if (!(depth
& TIPC_NTQ_ALLTYPES
) &&
817 (type
!= nla_get_u32(publ
[TIPC_NLA_PUBL_TYPE
])))
819 if (lowbound
&& (lowbound
> nla_get_u32(publ
[TIPC_NLA_PUBL_UPPER
])))
821 if (upbound
&& (upbound
< nla_get_u32(publ
[TIPC_NLA_PUBL_LOWER
])))
824 tipc_tlv_sprintf(msg
->rep
, "%-10u ",
825 nla_get_u32(publ
[TIPC_NLA_PUBL_TYPE
]));
830 tipc_tlv_sprintf(msg
->rep
, "%-10u %-10u ",
831 nla_get_u32(publ
[TIPC_NLA_PUBL_LOWER
]),
832 nla_get_u32(publ
[TIPC_NLA_PUBL_UPPER
]));
837 node
= nla_get_u32(publ
[TIPC_NLA_PUBL_NODE
]);
838 sprintf(port_str
, "<%u.%u.%u:%u>", tipc_zone(node
), tipc_cluster(node
),
839 tipc_node(node
), nla_get_u32(publ
[TIPC_NLA_PUBL_REF
]));
840 tipc_tlv_sprintf(msg
->rep
, "%-26s ", port_str
);
845 tipc_tlv_sprintf(msg
->rep
, "%-10u %s",
846 nla_get_u32(publ
[TIPC_NLA_PUBL_KEY
]),
847 scope_str
[nla_get_u32(publ
[TIPC_NLA_PUBL_SCOPE
])]);
849 tipc_tlv_sprintf(msg
->rep
, "\n");
854 static int __tipc_nl_compat_publ_dump(struct tipc_nl_compat_msg
*msg
,
855 struct nlattr
**attrs
)
857 u32 type
, lower
, upper
;
858 struct nlattr
*publ
[TIPC_NLA_PUBL_MAX
+ 1];
861 if (!attrs
[TIPC_NLA_PUBL
])
864 err
= nla_parse_nested(publ
, TIPC_NLA_PUBL_MAX
, attrs
[TIPC_NLA_PUBL
],
869 type
= nla_get_u32(publ
[TIPC_NLA_PUBL_TYPE
]);
870 lower
= nla_get_u32(publ
[TIPC_NLA_PUBL_LOWER
]);
871 upper
= nla_get_u32(publ
[TIPC_NLA_PUBL_UPPER
]);
874 tipc_tlv_sprintf(msg
->rep
, " {%u,%u}", type
, lower
);
876 tipc_tlv_sprintf(msg
->rep
, " {%u,%u,%u}", type
, lower
, upper
);
881 static int tipc_nl_compat_publ_dump(struct tipc_nl_compat_msg
*msg
, u32 sock
)
886 struct sk_buff
*args
;
887 struct tipc_nl_compat_cmd_dump dump
;
889 args
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
893 hdr
= genlmsg_put(args
, 0, 0, &tipc_genl_family
, NLM_F_MULTI
,
896 nest
= nla_nest_start(args
, TIPC_NLA_SOCK
);
902 if (nla_put_u32(args
, TIPC_NLA_SOCK_REF
, sock
)) {
907 nla_nest_end(args
, nest
);
908 genlmsg_end(args
, hdr
);
910 dump
.dumpit
= tipc_nl_publ_dump
;
911 dump
.format
= __tipc_nl_compat_publ_dump
;
913 err
= __tipc_nl_compat_dumpit(&dump
, msg
, args
);
920 static int tipc_nl_compat_sk_dump(struct tipc_nl_compat_msg
*msg
,
921 struct nlattr
**attrs
)
925 struct nlattr
*sock
[TIPC_NLA_SOCK_MAX
+ 1];
927 if (!attrs
[TIPC_NLA_SOCK
])
930 err
= nla_parse_nested(sock
, TIPC_NLA_SOCK_MAX
, attrs
[TIPC_NLA_SOCK
],
935 sock_ref
= nla_get_u32(sock
[TIPC_NLA_SOCK_REF
]);
936 tipc_tlv_sprintf(msg
->rep
, "%u:", sock_ref
);
938 if (sock
[TIPC_NLA_SOCK_CON
]) {
940 struct nlattr
*con
[TIPC_NLA_CON_MAX
+ 1];
942 nla_parse_nested(con
, TIPC_NLA_CON_MAX
, sock
[TIPC_NLA_SOCK_CON
],
945 node
= nla_get_u32(con
[TIPC_NLA_CON_NODE
]);
946 tipc_tlv_sprintf(msg
->rep
, " connected to <%u.%u.%u:%u>",
950 nla_get_u32(con
[TIPC_NLA_CON_SOCK
]));
952 if (con
[TIPC_NLA_CON_FLAG
])
953 tipc_tlv_sprintf(msg
->rep
, " via {%u,%u}\n",
954 nla_get_u32(con
[TIPC_NLA_CON_TYPE
]),
955 nla_get_u32(con
[TIPC_NLA_CON_INST
]));
957 tipc_tlv_sprintf(msg
->rep
, "\n");
958 } else if (sock
[TIPC_NLA_SOCK_HAS_PUBL
]) {
959 tipc_tlv_sprintf(msg
->rep
, " bound to");
961 err
= tipc_nl_compat_publ_dump(msg
, sock_ref
);
965 tipc_tlv_sprintf(msg
->rep
, "\n");
970 static int tipc_nl_compat_media_dump(struct tipc_nl_compat_msg
*msg
,
971 struct nlattr
**attrs
)
973 struct nlattr
*media
[TIPC_NLA_MEDIA_MAX
+ 1];
976 if (!attrs
[TIPC_NLA_MEDIA
])
979 err
= nla_parse_nested(media
, TIPC_NLA_MEDIA_MAX
, attrs
[TIPC_NLA_MEDIA
],
984 return tipc_add_tlv(msg
->rep
, TIPC_TLV_MEDIA_NAME
,
985 nla_data(media
[TIPC_NLA_MEDIA_NAME
]),
986 nla_len(media
[TIPC_NLA_MEDIA_NAME
]));
989 static int tipc_nl_compat_node_dump(struct tipc_nl_compat_msg
*msg
,
990 struct nlattr
**attrs
)
992 struct tipc_node_info node_info
;
993 struct nlattr
*node
[TIPC_NLA_NODE_MAX
+ 1];
996 if (!attrs
[TIPC_NLA_NODE
])
999 err
= nla_parse_nested(node
, TIPC_NLA_NODE_MAX
, attrs
[TIPC_NLA_NODE
],
1004 node_info
.addr
= htonl(nla_get_u32(node
[TIPC_NLA_NODE_ADDR
]));
1005 node_info
.up
= htonl(nla_get_flag(node
[TIPC_NLA_NODE_UP
]));
1007 return tipc_add_tlv(msg
->rep
, TIPC_TLV_NODE_INFO
, &node_info
,
1011 static int tipc_nl_compat_net_set(struct tipc_nl_compat_cmd_doit
*cmd
,
1012 struct sk_buff
*skb
,
1013 struct tipc_nl_compat_msg
*msg
)
1018 val
= ntohl(*(__be32
*)TLV_DATA(msg
->req
));
1020 net
= nla_nest_start(skb
, TIPC_NLA_NET
);
1024 if (msg
->cmd
== TIPC_CMD_SET_NODE_ADDR
) {
1025 if (nla_put_u32(skb
, TIPC_NLA_NET_ADDR
, val
))
1027 } else if (msg
->cmd
== TIPC_CMD_SET_NETID
) {
1028 if (nla_put_u32(skb
, TIPC_NLA_NET_ID
, val
))
1031 nla_nest_end(skb
, net
);
1036 static int tipc_nl_compat_net_dump(struct tipc_nl_compat_msg
*msg
,
1037 struct nlattr
**attrs
)
1040 struct nlattr
*net
[TIPC_NLA_NET_MAX
+ 1];
1043 if (!attrs
[TIPC_NLA_NET
])
1046 err
= nla_parse_nested(net
, TIPC_NLA_NET_MAX
, attrs
[TIPC_NLA_NET
],
1051 id
= htonl(nla_get_u32(net
[TIPC_NLA_NET_ID
]));
1053 return tipc_add_tlv(msg
->rep
, TIPC_TLV_UNSIGNED
, &id
, sizeof(id
));
1056 static int tipc_cmd_show_stats_compat(struct tipc_nl_compat_msg
*msg
)
1058 msg
->rep
= tipc_tlv_alloc(ULTRA_STRING_MAX_LEN
);
1062 tipc_tlv_init(msg
->rep
, TIPC_TLV_ULTRA_STRING
);
1063 tipc_tlv_sprintf(msg
->rep
, "TIPC version " TIPC_MOD_VER
"\n");
1068 static int tipc_nl_compat_handle(struct tipc_nl_compat_msg
*msg
)
1070 struct tipc_nl_compat_cmd_dump dump
;
1071 struct tipc_nl_compat_cmd_doit doit
;
1073 memset(&dump
, 0, sizeof(dump
));
1074 memset(&doit
, 0, sizeof(doit
));
1078 msg
->rep
= tipc_tlv_alloc(0);
1082 case TIPC_CMD_GET_BEARER_NAMES
:
1083 msg
->rep_size
= MAX_BEARERS
* TLV_SPACE(TIPC_MAX_BEARER_NAME
);
1084 dump
.dumpit
= tipc_nl_bearer_dump
;
1085 dump
.format
= tipc_nl_compat_bearer_dump
;
1086 return tipc_nl_compat_dumpit(&dump
, msg
);
1087 case TIPC_CMD_ENABLE_BEARER
:
1088 msg
->req_type
= TIPC_TLV_BEARER_CONFIG
;
1089 doit
.doit
= tipc_nl_bearer_enable
;
1090 doit
.transcode
= tipc_nl_compat_bearer_enable
;
1091 return tipc_nl_compat_doit(&doit
, msg
);
1092 case TIPC_CMD_DISABLE_BEARER
:
1093 msg
->req_type
= TIPC_TLV_BEARER_NAME
;
1094 doit
.doit
= tipc_nl_bearer_disable
;
1095 doit
.transcode
= tipc_nl_compat_bearer_disable
;
1096 return tipc_nl_compat_doit(&doit
, msg
);
1097 case TIPC_CMD_SHOW_LINK_STATS
:
1098 msg
->req_type
= TIPC_TLV_LINK_NAME
;
1099 msg
->rep_size
= ULTRA_STRING_MAX_LEN
;
1100 msg
->rep_type
= TIPC_TLV_ULTRA_STRING
;
1101 dump
.dumpit
= tipc_nl_node_dump_link
;
1102 dump
.format
= tipc_nl_compat_link_stat_dump
;
1103 return tipc_nl_compat_dumpit(&dump
, msg
);
1104 case TIPC_CMD_GET_LINKS
:
1105 msg
->req_type
= TIPC_TLV_NET_ADDR
;
1106 msg
->rep_size
= ULTRA_STRING_MAX_LEN
;
1107 dump
.dumpit
= tipc_nl_node_dump_link
;
1108 dump
.format
= tipc_nl_compat_link_dump
;
1109 return tipc_nl_compat_dumpit(&dump
, msg
);
1110 case TIPC_CMD_SET_LINK_TOL
:
1111 case TIPC_CMD_SET_LINK_PRI
:
1112 case TIPC_CMD_SET_LINK_WINDOW
:
1113 msg
->req_type
= TIPC_TLV_LINK_CONFIG
;
1114 doit
.doit
= tipc_nl_node_set_link
;
1115 doit
.transcode
= tipc_nl_compat_link_set
;
1116 return tipc_nl_compat_doit(&doit
, msg
);
1117 case TIPC_CMD_RESET_LINK_STATS
:
1118 msg
->req_type
= TIPC_TLV_LINK_NAME
;
1119 doit
.doit
= tipc_nl_node_reset_link_stats
;
1120 doit
.transcode
= tipc_nl_compat_link_reset_stats
;
1121 return tipc_nl_compat_doit(&doit
, msg
);
1122 case TIPC_CMD_SHOW_NAME_TABLE
:
1123 msg
->req_type
= TIPC_TLV_NAME_TBL_QUERY
;
1124 msg
->rep_size
= ULTRA_STRING_MAX_LEN
;
1125 msg
->rep_type
= TIPC_TLV_ULTRA_STRING
;
1126 dump
.header
= tipc_nl_compat_name_table_dump_header
;
1127 dump
.dumpit
= tipc_nl_name_table_dump
;
1128 dump
.format
= tipc_nl_compat_name_table_dump
;
1129 return tipc_nl_compat_dumpit(&dump
, msg
);
1130 case TIPC_CMD_SHOW_PORTS
:
1131 msg
->rep_size
= ULTRA_STRING_MAX_LEN
;
1132 msg
->rep_type
= TIPC_TLV_ULTRA_STRING
;
1133 dump
.dumpit
= tipc_nl_sk_dump
;
1134 dump
.format
= tipc_nl_compat_sk_dump
;
1135 return tipc_nl_compat_dumpit(&dump
, msg
);
1136 case TIPC_CMD_GET_MEDIA_NAMES
:
1137 msg
->rep_size
= MAX_MEDIA
* TLV_SPACE(TIPC_MAX_MEDIA_NAME
);
1138 dump
.dumpit
= tipc_nl_media_dump
;
1139 dump
.format
= tipc_nl_compat_media_dump
;
1140 return tipc_nl_compat_dumpit(&dump
, msg
);
1141 case TIPC_CMD_GET_NODES
:
1142 msg
->rep_size
= ULTRA_STRING_MAX_LEN
;
1143 dump
.dumpit
= tipc_nl_node_dump
;
1144 dump
.format
= tipc_nl_compat_node_dump
;
1145 return tipc_nl_compat_dumpit(&dump
, msg
);
1146 case TIPC_CMD_SET_NODE_ADDR
:
1147 msg
->req_type
= TIPC_TLV_NET_ADDR
;
1148 doit
.doit
= tipc_nl_net_set
;
1149 doit
.transcode
= tipc_nl_compat_net_set
;
1150 return tipc_nl_compat_doit(&doit
, msg
);
1151 case TIPC_CMD_SET_NETID
:
1152 msg
->req_type
= TIPC_TLV_UNSIGNED
;
1153 doit
.doit
= tipc_nl_net_set
;
1154 doit
.transcode
= tipc_nl_compat_net_set
;
1155 return tipc_nl_compat_doit(&doit
, msg
);
1156 case TIPC_CMD_GET_NETID
:
1157 msg
->rep_size
= sizeof(u32
);
1158 dump
.dumpit
= tipc_nl_net_dump
;
1159 dump
.format
= tipc_nl_compat_net_dump
;
1160 return tipc_nl_compat_dumpit(&dump
, msg
);
1161 case TIPC_CMD_SHOW_STATS
:
1162 return tipc_cmd_show_stats_compat(msg
);
1168 static int tipc_nl_compat_recv(struct sk_buff
*skb
, struct genl_info
*info
)
1172 struct tipc_nl_compat_msg msg
;
1173 struct nlmsghdr
*req_nlh
;
1174 struct nlmsghdr
*rep_nlh
;
1175 struct tipc_genlmsghdr
*req_userhdr
= info
->userhdr
;
1177 memset(&msg
, 0, sizeof(msg
));
1179 req_nlh
= (struct nlmsghdr
*)skb
->data
;
1180 msg
.req
= nlmsg_data(req_nlh
) + GENL_HDRLEN
+ TIPC_GENL_HDRLEN
;
1181 msg
.cmd
= req_userhdr
->cmd
;
1182 msg
.net
= genl_info_net(info
);
1183 msg
.dst_sk
= skb
->sk
;
1185 if ((msg
.cmd
& 0xC000) && (!netlink_net_capable(skb
, CAP_NET_ADMIN
))) {
1186 msg
.rep
= tipc_get_err_tlv(TIPC_CFG_NOT_NET_ADMIN
);
1191 len
= nlmsg_attrlen(req_nlh
, GENL_HDRLEN
+ TIPC_GENL_HDRLEN
);
1192 if (len
&& !TLV_OK(msg
.req
, len
)) {
1193 msg
.rep
= tipc_get_err_tlv(TIPC_CFG_NOT_SUPPORTED
);
1198 err
= tipc_nl_compat_handle(&msg
);
1199 if ((err
== -EOPNOTSUPP
) || (err
== -EPERM
))
1200 msg
.rep
= tipc_get_err_tlv(TIPC_CFG_NOT_SUPPORTED
);
1201 else if (err
== -EINVAL
)
1202 msg
.rep
= tipc_get_err_tlv(TIPC_CFG_TLV_ERROR
);
1207 len
= nlmsg_total_size(GENL_HDRLEN
+ TIPC_GENL_HDRLEN
);
1208 skb_push(msg
.rep
, len
);
1209 rep_nlh
= nlmsg_hdr(msg
.rep
);
1210 memcpy(rep_nlh
, info
->nlhdr
, len
);
1211 rep_nlh
->nlmsg_len
= msg
.rep
->len
;
1212 genlmsg_unicast(msg
.net
, msg
.rep
, NETLINK_CB(skb
).portid
);
1217 static struct genl_family tipc_genl_compat_family
= {
1218 .id
= GENL_ID_GENERATE
,
1219 .name
= TIPC_GENL_NAME
,
1220 .version
= TIPC_GENL_VERSION
,
1221 .hdrsize
= TIPC_GENL_HDRLEN
,
1226 static struct genl_ops tipc_genl_compat_ops
[] = {
1228 .cmd
= TIPC_GENL_CMD
,
1229 .doit
= tipc_nl_compat_recv
,
1233 int tipc_netlink_compat_start(void)
1237 res
= genl_register_family_with_ops(&tipc_genl_compat_family
,
1238 tipc_genl_compat_ops
);
1240 pr_err("Failed to register legacy compat interface\n");
1247 void tipc_netlink_compat_stop(void)
1249 genl_unregister_family(&tipc_genl_compat_family
);