1 /* 2 * ctrl.c generic netlink controller 3 * 4 * This program is free software; you can distribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation; either version 7 * 2 of the License, or (at your option) any later version. 8 * 9 * Authors: J Hadi Salim (hadi@cyberus.ca) 10 * Johannes Berg (johannes@sipsolutions.net) 11 */ 12 13 #include <stdio.h> 14 #include <stdlib.h> 15 #include <unistd.h> 16 #include <syslog.h> 17 #include <fcntl.h> 18 #include <sys/socket.h> 19 #include <netinet/in.h> 20 #include <arpa/inet.h> 21 #include <string.h> 22 23 #include "utils.h" 24 #include "genl_utils.h" 25 26 #define GENL_MAX_FAM_OPS 256 27 #define GENL_MAX_FAM_GRPS 256 28 usage(void)29 static int usage(void) 30 { 31 fprintf(stderr,"Usage: ctrl <CMD>\n" \ 32 "CMD := get <PARMS> | list | monitor\n" \ 33 "PARMS := name <name> | id <id>\n" \ 34 "Examples:\n" \ 35 "\tctrl ls\n" \ 36 "\tctrl monitor\n" \ 37 "\tctrl get name foobar\n" \ 38 "\tctrl get id 0xF\n"); 39 return -1; 40 } 41 genl_ctrl_resolve_family(const char * family)42 int genl_ctrl_resolve_family(const char *family) 43 { 44 struct rtnl_handle rth; 45 struct nlmsghdr *nlh; 46 struct genlmsghdr *ghdr; 47 int ret = 0; 48 struct { 49 struct nlmsghdr n; 50 char buf[4096]; 51 } req; 52 53 memset(&req, 0, sizeof(req)); 54 55 nlh = &req.n; 56 nlh->nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN); 57 nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; 58 nlh->nlmsg_type = GENL_ID_CTRL; 59 60 ghdr = NLMSG_DATA(&req.n); 61 ghdr->cmd = CTRL_CMD_GETFAMILY; 62 63 if (rtnl_open_byproto(&rth, 0, NETLINK_GENERIC) < 0) { 64 fprintf(stderr, "Cannot open generic netlink socket\n"); 65 exit(1); 66 } 67 68 addattr_l(nlh, 128, CTRL_ATTR_FAMILY_NAME, family, strlen(family) + 1); 69 70 if (rtnl_talk(&rth, nlh, 0, 0, nlh) < 0) { 71 fprintf(stderr, "Error talking to the kernel\n"); 72 goto errout; 73 } 74 75 { 76 struct rtattr *tb[CTRL_ATTR_MAX + 1]; 77 struct genlmsghdr *ghdr = NLMSG_DATA(nlh); 78 int len = nlh->nlmsg_len; 79 struct rtattr *attrs; 80 81 if (nlh->nlmsg_type != GENL_ID_CTRL) { 82 fprintf(stderr, "Not a controller message, nlmsg_len=%d " 83 "nlmsg_type=0x%x\n", nlh->nlmsg_len, nlh->nlmsg_type); 84 goto errout; 85 } 86 87 if (ghdr->cmd != CTRL_CMD_NEWFAMILY) { 88 fprintf(stderr, "Unknown controller command %d\n", ghdr->cmd); 89 goto errout; 90 } 91 92 len -= NLMSG_LENGTH(GENL_HDRLEN); 93 94 if (len < 0) { 95 fprintf(stderr, "wrong controller message len %d\n", len); 96 return -1; 97 } 98 99 attrs = (struct rtattr *) ((char *) ghdr + GENL_HDRLEN); 100 parse_rtattr(tb, CTRL_ATTR_MAX, attrs, len); 101 102 if (tb[CTRL_ATTR_FAMILY_ID] == NULL) { 103 fprintf(stderr, "Missing family id TLV\n"); 104 goto errout; 105 } 106 107 ret = rta_getattr_u16(tb[CTRL_ATTR_FAMILY_ID]); 108 } 109 110 errout: 111 rtnl_close(&rth); 112 return ret; 113 } 114 print_ctrl_cmd_flags(FILE * fp,__u32 fl)115 void print_ctrl_cmd_flags(FILE *fp, __u32 fl) 116 { 117 fprintf(fp, "\n\t\tCapabilities (0x%x):\n ", fl); 118 if (!fl) { 119 fprintf(fp, "\n"); 120 return; 121 } 122 fprintf(fp, "\t\t "); 123 124 if (fl & GENL_ADMIN_PERM) 125 fprintf(fp, " requires admin permission;"); 126 if (fl & GENL_CMD_CAP_DO) 127 fprintf(fp, " can doit;"); 128 if (fl & GENL_CMD_CAP_DUMP) 129 fprintf(fp, " can dumpit;"); 130 if (fl & GENL_CMD_CAP_HASPOL) 131 fprintf(fp, " has policy"); 132 133 fprintf(fp, "\n"); 134 } 135 print_ctrl_cmds(FILE * fp,struct rtattr * arg,__u32 ctrl_ver)136 static int print_ctrl_cmds(FILE *fp, struct rtattr *arg, __u32 ctrl_ver) 137 { 138 struct rtattr *tb[CTRL_ATTR_OP_MAX + 1]; 139 140 if (arg == NULL) 141 return -1; 142 143 parse_rtattr_nested(tb, CTRL_ATTR_OP_MAX, arg); 144 if (tb[CTRL_ATTR_OP_ID]) { 145 __u32 *id = RTA_DATA(tb[CTRL_ATTR_OP_ID]); 146 fprintf(fp, " ID-0x%x ",*id); 147 } 148 /* we are only gonna do this for newer version of the controller */ 149 if (tb[CTRL_ATTR_OP_FLAGS] && ctrl_ver >= 0x2) { 150 __u32 *fl = RTA_DATA(tb[CTRL_ATTR_OP_FLAGS]); 151 print_ctrl_cmd_flags(fp, *fl); 152 } 153 return 0; 154 155 } 156 print_ctrl_grp(FILE * fp,struct rtattr * arg,__u32 ctrl_ver)157 static int print_ctrl_grp(FILE *fp, struct rtattr *arg, __u32 ctrl_ver) 158 { 159 struct rtattr *tb[CTRL_ATTR_MCAST_GRP_MAX + 1]; 160 161 if (arg == NULL) 162 return -1; 163 164 parse_rtattr_nested(tb, CTRL_ATTR_MCAST_GRP_MAX, arg); 165 if (tb[2]) { 166 __u32 *id = RTA_DATA(tb[CTRL_ATTR_MCAST_GRP_ID]); 167 fprintf(fp, " ID-0x%x ",*id); 168 } 169 if (tb[1]) { 170 char *name = RTA_DATA(tb[CTRL_ATTR_MCAST_GRP_NAME]); 171 fprintf(fp, " name: %s ", name); 172 } 173 return 0; 174 175 } 176 177 /* 178 * The controller sends one nlmsg per family 179 */ print_ctrl(const struct sockaddr_nl * who,struct nlmsghdr * n,void * arg)180 static int print_ctrl(const struct sockaddr_nl *who, struct nlmsghdr *n, 181 void *arg) 182 { 183 struct rtattr *tb[CTRL_ATTR_MAX + 1]; 184 struct genlmsghdr *ghdr = NLMSG_DATA(n); 185 int len = n->nlmsg_len; 186 struct rtattr *attrs; 187 FILE *fp = (FILE *) arg; 188 __u32 ctrl_v = 0x1; 189 190 if (n->nlmsg_type != GENL_ID_CTRL) { 191 fprintf(stderr, "Not a controller message, nlmsg_len=%d " 192 "nlmsg_type=0x%x\n", n->nlmsg_len, n->nlmsg_type); 193 return 0; 194 } 195 196 if (ghdr->cmd != CTRL_CMD_GETFAMILY && 197 ghdr->cmd != CTRL_CMD_DELFAMILY && 198 ghdr->cmd != CTRL_CMD_NEWFAMILY && 199 ghdr->cmd != CTRL_CMD_NEWMCAST_GRP && 200 ghdr->cmd != CTRL_CMD_DELMCAST_GRP) { 201 fprintf(stderr, "Unknown controller command %d\n", ghdr->cmd); 202 return 0; 203 } 204 205 len -= NLMSG_LENGTH(GENL_HDRLEN); 206 207 if (len < 0) { 208 fprintf(stderr, "wrong controller message len %d\n", len); 209 return -1; 210 } 211 212 attrs = (struct rtattr *) ((char *) ghdr + GENL_HDRLEN); 213 parse_rtattr(tb, CTRL_ATTR_MAX, attrs, len); 214 215 if (tb[CTRL_ATTR_FAMILY_NAME]) { 216 char *name = RTA_DATA(tb[CTRL_ATTR_FAMILY_NAME]); 217 fprintf(fp, "\nName: %s\n",name); 218 } 219 if (tb[CTRL_ATTR_FAMILY_ID]) { 220 __u16 *id = RTA_DATA(tb[CTRL_ATTR_FAMILY_ID]); 221 fprintf(fp, "\tID: 0x%x ",*id); 222 } 223 if (tb[CTRL_ATTR_VERSION]) { 224 __u32 *v = RTA_DATA(tb[CTRL_ATTR_VERSION]); 225 fprintf(fp, " Version: 0x%x ",*v); 226 ctrl_v = *v; 227 } 228 if (tb[CTRL_ATTR_HDRSIZE]) { 229 __u32 *h = RTA_DATA(tb[CTRL_ATTR_HDRSIZE]); 230 fprintf(fp, " header size: %d ",*h); 231 } 232 if (tb[CTRL_ATTR_MAXATTR]) { 233 __u32 *ma = RTA_DATA(tb[CTRL_ATTR_MAXATTR]); 234 fprintf(fp, " max attribs: %d ",*ma); 235 } 236 /* end of family definitions .. */ 237 fprintf(fp,"\n"); 238 if (tb[CTRL_ATTR_OPS]) { 239 struct rtattr *tb2[GENL_MAX_FAM_OPS]; 240 int i=0; 241 parse_rtattr_nested(tb2, GENL_MAX_FAM_OPS, tb[CTRL_ATTR_OPS]); 242 fprintf(fp, "\tcommands supported: \n"); 243 for (i = 0; i < GENL_MAX_FAM_OPS; i++) { 244 if (tb2[i]) { 245 fprintf(fp, "\t\t#%d: ", i); 246 if (0 > print_ctrl_cmds(fp, tb2[i], ctrl_v)) { 247 fprintf(fp, "Error printing command\n"); 248 } 249 /* for next command */ 250 fprintf(fp,"\n"); 251 } 252 } 253 254 /* end of family::cmds definitions .. */ 255 fprintf(fp,"\n"); 256 } 257 258 if (tb[CTRL_ATTR_MCAST_GROUPS]) { 259 struct rtattr *tb2[GENL_MAX_FAM_GRPS + 1]; 260 int i; 261 262 parse_rtattr_nested(tb2, GENL_MAX_FAM_GRPS, 263 tb[CTRL_ATTR_MCAST_GROUPS]); 264 fprintf(fp, "\tmulticast groups:\n"); 265 266 for (i = 0; i < GENL_MAX_FAM_GRPS; i++) { 267 if (tb2[i]) { 268 fprintf(fp, "\t\t#%d: ", i); 269 if (0 > print_ctrl_grp(fp, tb2[i], ctrl_v)) 270 fprintf(fp, "Error printing group\n"); 271 /* for next group */ 272 fprintf(fp,"\n"); 273 } 274 } 275 276 /* end of family::groups definitions .. */ 277 fprintf(fp,"\n"); 278 } 279 280 fflush(fp); 281 return 0; 282 } 283 ctrl_list(int cmd,int argc,char ** argv)284 static int ctrl_list(int cmd, int argc, char **argv) 285 { 286 struct rtnl_handle rth; 287 struct nlmsghdr *nlh; 288 struct genlmsghdr *ghdr; 289 int ret = -1; 290 char d[GENL_NAMSIZ]; 291 struct { 292 struct nlmsghdr n; 293 char buf[4096]; 294 } req; 295 296 memset(&req, 0, sizeof(req)); 297 298 nlh = &req.n; 299 nlh->nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN); 300 nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; 301 nlh->nlmsg_type = GENL_ID_CTRL; 302 303 ghdr = NLMSG_DATA(&req.n); 304 ghdr->cmd = CTRL_CMD_GETFAMILY; 305 306 if (rtnl_open_byproto(&rth, 0, NETLINK_GENERIC) < 0) { 307 fprintf(stderr, "Cannot open generic netlink socket\n"); 308 exit(1); 309 } 310 311 if (cmd == CTRL_CMD_GETFAMILY) { 312 if (argc != 2) { 313 fprintf(stderr, "Wrong number of params\n"); 314 return -1; 315 } 316 317 if (matches(*argv, "name") == 0) { 318 NEXT_ARG(); 319 strncpy(d, *argv, sizeof (d) - 1); 320 addattr_l(nlh, 128, CTRL_ATTR_FAMILY_NAME, 321 d, strlen(d) + 1); 322 } else if (matches(*argv, "id") == 0) { 323 __u16 id; 324 NEXT_ARG(); 325 if (get_u16(&id, *argv, 0)) { 326 fprintf(stderr, "Illegal \"id\"\n"); 327 goto ctrl_done; 328 } 329 330 addattr_l(nlh, 128, CTRL_ATTR_FAMILY_ID, &id, 2); 331 332 } else { 333 fprintf(stderr, "Wrong params\n"); 334 goto ctrl_done; 335 } 336 337 if (rtnl_talk(&rth, nlh, 0, 0, nlh) < 0) { 338 fprintf(stderr, "Error talking to the kernel\n"); 339 goto ctrl_done; 340 } 341 342 if (print_ctrl(NULL, nlh, (void *) stdout) < 0) { 343 fprintf(stderr, "Dump terminated\n"); 344 goto ctrl_done; 345 } 346 347 } 348 349 if (cmd == CTRL_CMD_UNSPEC) { 350 nlh->nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST; 351 nlh->nlmsg_seq = rth.dump = ++rth.seq; 352 353 if (rtnl_send(&rth, nlh, nlh->nlmsg_len) < 0) { 354 perror("Failed to send dump request\n"); 355 goto ctrl_done; 356 } 357 358 rtnl_dump_filter(&rth, print_ctrl, stdout); 359 360 } 361 362 ret = 0; 363 ctrl_done: 364 rtnl_close(&rth); 365 return ret; 366 } 367 ctrl_listen(int argc,char ** argv)368 static int ctrl_listen(int argc, char **argv) 369 { 370 struct rtnl_handle rth; 371 372 if (rtnl_open_byproto(&rth, nl_mgrp(GENL_ID_CTRL), NETLINK_GENERIC) < 0) { 373 fprintf(stderr, "Canot open generic netlink socket\n"); 374 return -1; 375 } 376 377 if (rtnl_listen(&rth, print_ctrl, (void *) stdout) < 0) 378 return -1; 379 380 return 0; 381 } 382 parse_ctrl(struct genl_util * a,int argc,char ** argv)383 static int parse_ctrl(struct genl_util *a, int argc, char **argv) 384 { 385 argv++; 386 if (--argc <= 0) { 387 fprintf(stderr, "wrong controller params\n"); 388 return -1; 389 } 390 391 if (matches(*argv, "monitor") == 0) 392 return ctrl_listen(argc-1, argv+1); 393 if (matches(*argv, "get") == 0) 394 return ctrl_list(CTRL_CMD_GETFAMILY, argc-1, argv+1); 395 if (matches(*argv, "list") == 0 || 396 matches(*argv, "show") == 0 || 397 matches(*argv, "lst") == 0) 398 return ctrl_list(CTRL_CMD_UNSPEC, argc-1, argv+1); 399 if (matches(*argv, "help") == 0) 400 return usage(); 401 402 fprintf(stderr, "ctrl command \"%s\" is unknown, try \"ctrl -help\".\n", 403 *argv); 404 405 return -1; 406 } 407 408 struct genl_util ctrl_genl_util = { 409 .name = "ctrl", 410 .parse_genlopt = parse_ctrl, 411 .print_genlopt = print_ctrl, 412 }; 413