1 /* 2 * NETLINK Generic Netlink Family 3 * 4 * Authors: Jamal Hadi Salim 5 * Thomas Graf <tgraf@suug.ch> 6 */ 7 8 #include <linux/module.h> 9 #include <linux/kernel.h> 10 #include <linux/errno.h> 11 #include <linux/types.h> 12 #include <linux/socket.h> 13 #include <linux/string.h> 14 #include <linux/skbuff.h> 15 #include <linux/mutex.h> 16 #include <net/sock.h> 17 #include <net/genetlink.h> 18 19 struct sock *genl_sock = NULL; 20 21 static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */ 22 23 static void genl_lock(void) 24 { 25 mutex_lock(&genl_mutex); 26 } 27 28 static int genl_trylock(void) 29 { 30 return !mutex_trylock(&genl_mutex); 31 } 32 33 static void genl_unlock(void) 34 { 35 mutex_unlock(&genl_mutex); 36 37 if (genl_sock && genl_sock->sk_receive_queue.qlen) 38 genl_sock->sk_data_ready(genl_sock, 0); 39 } 40 41 #define GENL_FAM_TAB_SIZE 16 42 #define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1) 43 44 static struct list_head family_ht[GENL_FAM_TAB_SIZE]; 45 46 static int genl_ctrl_event(int event, void *data); 47 48 static inline unsigned int genl_family_hash(unsigned int id) 49 { 50 return id & GENL_FAM_TAB_MASK; 51 } 52 53 static inline struct list_head *genl_family_chain(unsigned int id) 54 { 55 return &family_ht[genl_family_hash(id)]; 56 } 57 58 static struct genl_family *genl_family_find_byid(unsigned int id) 59 { 60 struct genl_family *f; 61 62 list_for_each_entry(f, genl_family_chain(id), family_list) 63 if (f->id == id) 64 return f; 65 66 return NULL; 67 } 68 69 static struct genl_family *genl_family_find_byname(char *name) 70 { 71 struct genl_family *f; 72 int i; 73 74 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) 75 list_for_each_entry(f, genl_family_chain(i), family_list) 76 if (strcmp(f->name, name) == 0) 77 return f; 78 79 return NULL; 80 } 81 82 static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family) 83 { 84 struct genl_ops *ops; 85 86 list_for_each_entry(ops, &family->ops_list, ops_list) 87 if (ops->cmd == cmd) 88 return ops; 89 90 return NULL; 91 } 92 93 /* Of course we are going to have problems once we hit 94 * 2^16 alive types, but that can only happen by year 2K 95 */ 96 static inline u16 genl_generate_id(void) 97 { 98 static u16 id_gen_idx; 99 int overflowed = 0; 100 101 do { 102 if (id_gen_idx == 0) 103 id_gen_idx = GENL_MIN_ID; 104 105 if (++id_gen_idx > GENL_MAX_ID) { 106 if (!overflowed) { 107 overflowed = 1; 108 id_gen_idx = 0; 109 continue; 110 } else 111 return 0; 112 } 113 114 } while (genl_family_find_byid(id_gen_idx)); 115 116 return id_gen_idx; 117 } 118 119 /** 120 * genl_register_ops - register generic netlink operations 121 * @family: generic netlink family 122 * @ops: operations to be registered 123 * 124 * Registers the specified operations and assigns them to the specified 125 * family. Either a doit or dumpit callback must be specified or the 126 * operation will fail. Only one operation structure per command 127 * identifier may be registered. 128 * 129 * See include/net/genetlink.h for more documenation on the operations 130 * structure. 131 * 132 * Returns 0 on success or a negative error code. 133 */ 134 int genl_register_ops(struct genl_family *family, struct genl_ops *ops) 135 { 136 int err = -EINVAL; 137 138 if (ops->dumpit == NULL && ops->doit == NULL) 139 goto errout; 140 141 if (genl_get_cmd(ops->cmd, family)) { 142 err = -EEXIST; 143 goto errout; 144 } 145 146 genl_lock(); 147 list_add_tail(&ops->ops_list, &family->ops_list); 148 genl_unlock(); 149 150 genl_ctrl_event(CTRL_CMD_NEWOPS, ops); 151 err = 0; 152 errout: 153 return err; 154 } 155 156 /** 157 * genl_unregister_ops - unregister generic netlink operations 158 * @family: generic netlink family 159 * @ops: operations to be unregistered 160 * 161 * Unregisters the specified operations and unassigns them from the 162 * specified family. The operation blocks until the current message 163 * processing has finished and doesn't start again until the 164 * unregister process has finished. 165 * 166 * Note: It is not necessary to unregister all operations before 167 * unregistering the family, unregistering the family will cause 168 * all assigned operations to be unregistered automatically. 169 * 170 * Returns 0 on success or a negative error code. 171 */ 172 int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops) 173 { 174 struct genl_ops *rc; 175 176 genl_lock(); 177 list_for_each_entry(rc, &family->ops_list, ops_list) { 178 if (rc == ops) { 179 list_del(&ops->ops_list); 180 genl_unlock(); 181 genl_ctrl_event(CTRL_CMD_DELOPS, ops); 182 return 0; 183 } 184 } 185 genl_unlock(); 186 187 return -ENOENT; 188 } 189 190 /** 191 * genl_register_family - register a generic netlink family 192 * @family: generic netlink family 193 * 194 * Registers the specified family after validating it first. Only one 195 * family may be registered with the same family name or identifier. 196 * The family id may equal GENL_ID_GENERATE causing an unique id to 197 * be automatically generated and assigned. 198 * 199 * Return 0 on success or a negative error code. 200 */ 201 int genl_register_family(struct genl_family *family) 202 { 203 int err = -EINVAL; 204 205 if (family->id && family->id < GENL_MIN_ID) 206 goto errout; 207 208 if (family->id > GENL_MAX_ID) 209 goto errout; 210 211 INIT_LIST_HEAD(&family->ops_list); 212 213 genl_lock(); 214 215 if (genl_family_find_byname(family->name)) { 216 err = -EEXIST; 217 goto errout_locked; 218 } 219 220 if (genl_family_find_byid(family->id)) { 221 err = -EEXIST; 222 goto errout_locked; 223 } 224 225 if (family->id == GENL_ID_GENERATE) { 226 u16 newid = genl_generate_id(); 227 228 if (!newid) { 229 err = -ENOMEM; 230 goto errout_locked; 231 } 232 233 family->id = newid; 234 } 235 236 if (family->maxattr) { 237 family->attrbuf = kmalloc((family->maxattr+1) * 238 sizeof(struct nlattr *), GFP_KERNEL); 239 if (family->attrbuf == NULL) { 240 err = -ENOMEM; 241 goto errout_locked; 242 } 243 } else 244 family->attrbuf = NULL; 245 246 list_add_tail(&family->family_list, genl_family_chain(family->id)); 247 genl_unlock(); 248 249 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family); 250 251 return 0; 252 253 errout_locked: 254 genl_unlock(); 255 errout: 256 return err; 257 } 258 259 /** 260 * genl_unregister_family - unregister generic netlink family 261 * @family: generic netlink family 262 * 263 * Unregisters the specified family. 264 * 265 * Returns 0 on success or a negative error code. 266 */ 267 int genl_unregister_family(struct genl_family *family) 268 { 269 struct genl_family *rc; 270 271 genl_lock(); 272 273 list_for_each_entry(rc, genl_family_chain(family->id), family_list) { 274 if (family->id != rc->id || strcmp(rc->name, family->name)) 275 continue; 276 277 list_del(&rc->family_list); 278 INIT_LIST_HEAD(&family->ops_list); 279 genl_unlock(); 280 281 kfree(family->attrbuf); 282 genl_ctrl_event(CTRL_CMD_DELFAMILY, family); 283 return 0; 284 } 285 286 genl_unlock(); 287 288 return -ENOENT; 289 } 290 291 static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, 292 int *errp) 293 { 294 struct genl_ops *ops; 295 struct genl_family *family; 296 struct genl_info info; 297 struct genlmsghdr *hdr = nlmsg_data(nlh); 298 int hdrlen, err = -EINVAL; 299 300 if (!(nlh->nlmsg_flags & NLM_F_REQUEST)) 301 goto ignore; 302 303 if (nlh->nlmsg_type < NLMSG_MIN_TYPE) 304 goto ignore; 305 306 family = genl_family_find_byid(nlh->nlmsg_type); 307 if (family == NULL) { 308 err = -ENOENT; 309 goto errout; 310 } 311 312 hdrlen = GENL_HDRLEN + family->hdrsize; 313 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) 314 goto errout; 315 316 ops = genl_get_cmd(hdr->cmd, family); 317 if (ops == NULL) { 318 err = -EOPNOTSUPP; 319 goto errout; 320 } 321 322 if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb, CAP_NET_ADMIN)) { 323 err = -EPERM; 324 goto errout; 325 } 326 327 if (nlh->nlmsg_flags & NLM_F_DUMP) { 328 if (ops->dumpit == NULL) { 329 err = -EOPNOTSUPP; 330 goto errout; 331 } 332 333 *errp = err = netlink_dump_start(genl_sock, skb, nlh, 334 ops->dumpit, NULL); 335 if (err == 0) 336 skb_pull(skb, min(NLMSG_ALIGN(nlh->nlmsg_len), 337 skb->len)); 338 return -1; 339 } 340 341 if (ops->doit == NULL) { 342 err = -EOPNOTSUPP; 343 goto errout; 344 } 345 346 if (family->attrbuf) { 347 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr, 348 ops->policy); 349 if (err < 0) 350 goto errout; 351 } 352 353 info.snd_seq = nlh->nlmsg_seq; 354 info.snd_pid = NETLINK_CB(skb).pid; 355 info.nlhdr = nlh; 356 info.genlhdr = nlmsg_data(nlh); 357 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN; 358 info.attrs = family->attrbuf; 359 360 *errp = err = ops->doit(skb, &info); 361 return err; 362 363 ignore: 364 return 0; 365 366 errout: 367 *errp = err; 368 return -1; 369 } 370 371 static void genl_rcv(struct sock *sk, int len) 372 { 373 unsigned int qlen = 0; 374 375 do { 376 if (genl_trylock()) 377 return; 378 netlink_run_queue(sk, &qlen, genl_rcv_msg); 379 genl_unlock(); 380 } while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen); 381 } 382 383 /************************************************************************** 384 * Controller 385 **************************************************************************/ 386 387 static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq, 388 u32 flags, struct sk_buff *skb, u8 cmd) 389 { 390 void *hdr; 391 392 hdr = genlmsg_put(skb, pid, seq, GENL_ID_CTRL, 0, flags, cmd, 393 family->version); 394 if (hdr == NULL) 395 return -1; 396 397 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name); 398 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id); 399 400 return genlmsg_end(skb, hdr); 401 402 nla_put_failure: 403 return genlmsg_cancel(skb, hdr); 404 } 405 406 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb) 407 { 408 409 int i, n = 0; 410 struct genl_family *rt; 411 int chains_to_skip = cb->args[0]; 412 int fams_to_skip = cb->args[1]; 413 414 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) { 415 if (i < chains_to_skip) 416 continue; 417 n = 0; 418 list_for_each_entry(rt, genl_family_chain(i), family_list) { 419 if (++n < fams_to_skip) 420 continue; 421 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid, 422 cb->nlh->nlmsg_seq, NLM_F_MULTI, 423 skb, CTRL_CMD_NEWFAMILY) < 0) 424 goto errout; 425 } 426 427 fams_to_skip = 0; 428 } 429 430 errout: 431 cb->args[0] = i; 432 cb->args[1] = n; 433 434 return skb->len; 435 } 436 437 static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid, 438 int seq, u8 cmd) 439 { 440 struct sk_buff *skb; 441 int err; 442 443 skb = nlmsg_new(NLMSG_GOODSIZE); 444 if (skb == NULL) 445 return ERR_PTR(-ENOBUFS); 446 447 err = ctrl_fill_info(family, pid, seq, 0, skb, cmd); 448 if (err < 0) { 449 nlmsg_free(skb); 450 return ERR_PTR(err); 451 } 452 453 return skb; 454 } 455 456 static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] __read_mostly = { 457 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 }, 458 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_STRING }, 459 }; 460 461 static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info) 462 { 463 struct sk_buff *msg; 464 struct genl_family *res = NULL; 465 int err = -EINVAL; 466 467 if (info->attrs[CTRL_ATTR_FAMILY_ID]) { 468 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]); 469 res = genl_family_find_byid(id); 470 } 471 472 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) { 473 char name[GENL_NAMSIZ]; 474 475 if (nla_strlcpy(name, info->attrs[CTRL_ATTR_FAMILY_NAME], 476 GENL_NAMSIZ) >= GENL_NAMSIZ) 477 goto errout; 478 479 res = genl_family_find_byname(name); 480 } 481 482 if (res == NULL) { 483 err = -ENOENT; 484 goto errout; 485 } 486 487 msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq, 488 CTRL_CMD_NEWFAMILY); 489 if (IS_ERR(msg)) { 490 err = PTR_ERR(msg); 491 goto errout; 492 } 493 494 err = genlmsg_unicast(msg, info->snd_pid); 495 errout: 496 return err; 497 } 498 499 static int genl_ctrl_event(int event, void *data) 500 { 501 struct sk_buff *msg; 502 503 if (genl_sock == NULL) 504 return 0; 505 506 switch (event) { 507 case CTRL_CMD_NEWFAMILY: 508 case CTRL_CMD_DELFAMILY: 509 msg = ctrl_build_msg(data, 0, 0, event); 510 if (IS_ERR(msg)) 511 return PTR_ERR(msg); 512 513 genlmsg_multicast(msg, 0, GENL_ID_CTRL); 514 break; 515 } 516 517 return 0; 518 } 519 520 static struct genl_ops genl_ctrl_ops = { 521 .cmd = CTRL_CMD_GETFAMILY, 522 .doit = ctrl_getfamily, 523 .dumpit = ctrl_dumpfamily, 524 .policy = ctrl_policy, 525 }; 526 527 static struct genl_family genl_ctrl = { 528 .id = GENL_ID_CTRL, 529 .name = "nlctrl", 530 .version = 0x1, 531 .maxattr = CTRL_ATTR_MAX, 532 }; 533 534 static int __init genl_init(void) 535 { 536 int i, err; 537 538 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) 539 INIT_LIST_HEAD(&family_ht[i]); 540 541 err = genl_register_family(&genl_ctrl); 542 if (err < 0) 543 goto errout; 544 545 err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops); 546 if (err < 0) 547 goto errout_register; 548 549 netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV); 550 genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID, 551 genl_rcv, THIS_MODULE); 552 if (genl_sock == NULL) 553 panic("GENL: Cannot initialize generic netlink\n"); 554 555 return 0; 556 557 errout_register: 558 genl_unregister_family(&genl_ctrl); 559 errout: 560 panic("GENL: Cannot register controller: %d\n", err); 561 } 562 563 subsys_initcall(genl_init); 564 565 EXPORT_SYMBOL(genl_sock); 566 EXPORT_SYMBOL(genl_register_ops); 567 EXPORT_SYMBOL(genl_unregister_ops); 568 EXPORT_SYMBOL(genl_register_family); 569 EXPORT_SYMBOL(genl_unregister_family); 570