1 /* 2 * lib/nl.c Core Netlink Interface 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-2008 Thomas Graf <tgraf@suug.ch> 10 */ 11 12 /** 13 * @defgroup core Core 14 * 15 * @details 16 * @par 1) Connecting the socket 17 * @code 18 * // Bind and connect the socket to a protocol, NETLINK_ROUTE in this example. 19 * nl_connect(sk, NETLINK_ROUTE); 20 * @endcode 21 * 22 * @par 2) Sending data 23 * @code 24 * // The most rudimentary method is to use nl_sendto() simply pushing 25 * // a piece of data to the other netlink peer. This method is not 26 * // recommended. 27 * const char buf[] = { 0x01, 0x02, 0x03, 0x04 }; 28 * nl_sendto(sk, buf, sizeof(buf)); 29 * 30 * // A more comfortable interface is nl_send() taking a pointer to 31 * // a netlink message. 32 * struct nl_msg *msg = my_msg_builder(); 33 * nl_send(sk, nlmsg_hdr(msg)); 34 * 35 * // nl_sendmsg() provides additional control over the sendmsg() message 36 * // header in order to allow more specific addressing of multiple peers etc. 37 * struct msghdr hdr = { ... }; 38 * nl_sendmsg(sk, nlmsg_hdr(msg), &hdr); 39 * 40 * // You're probably too lazy to fill out the netlink pid, sequence number 41 * // and message flags all the time. nl_send_auto_complete() automatically 42 * // extends your message header as needed with an appropriate sequence 43 * // number, the netlink pid stored in the netlink socket and the message 44 * // flags NLM_F_REQUEST and NLM_F_ACK (if not disabled in the socket) 45 * nl_send_auto_complete(sk, nlmsg_hdr(msg)); 46 * 47 * // Simple protocols don't require the complex message construction interface 48 * // and may favour nl_send_simple() to easly send a bunch of payload 49 * // encapsulated in a netlink message header. 50 * nl_send_simple(sk, MY_MSG_TYPE, 0, buf, sizeof(buf)); 51 * @endcode 52 * 53 * @par 3) Receiving data 54 * @code 55 * // nl_recv() receives a single message allocating a buffer for the message 56 * // content and gives back the pointer to you. 57 * struct sockaddr_nl peer; 58 * unsigned char *msg; 59 * nl_recv(sk, &peer, &msg); 60 * 61 * // nl_recvmsgs() receives a bunch of messages until the callback system 62 * // orders it to state, usually after receving a compolete multi part 63 * // message series. 64 * nl_recvmsgs(sk, my_callback_configuration); 65 * 66 * // nl_recvmsgs_default() acts just like nl_recvmsg() but uses the callback 67 * // configuration stored in the socket. 68 * nl_recvmsgs_default(sk); 69 * 70 * // In case you want to wait for the ACK to be recieved that you requested 71 * // with your latest message, you can call nl_wait_for_ack() 72 * nl_wait_for_ack(sk); 73 * @endcode 74 * 75 * @par 4) Closing 76 * @code 77 * // Close the socket first to release kernel memory 78 * nl_close(sk); 79 * @endcode 80 * 81 * @{ 82 */ 83 84 #include <netlink-local.h> 85 #include <netlink/netlink.h> 86 #include <netlink/utils.h> 87 #include <netlink/handlers.h> 88 #include <netlink/msg.h> 89 #include <netlink/attr.h> 90 91 /** 92 * @name Connection Management 93 * @{ 94 */ 95 96 /** 97 * Create and connect netlink socket. 98 * @arg sk Netlink socket. 99 * @arg protocol Netlink protocol to use. 100 * 101 * Creates a netlink socket using the specified protocol, binds the socket 102 * and issues a connection attempt. 103 * 104 * @return 0 on success or a negative error code. 105 */ 106 int nl_connect(struct nl_sock *sk, int protocol) 107 { 108 int err; 109 int flags = 0; 110 socklen_t addrlen; 111 112 #ifdef SOCK_CLOEXEC 113 flags = SOCK_CLOEXEC; 114 #endif 115 116 sk->s_fd = socket(AF_NETLINK, SOCK_RAW | flags, protocol); 117 if (sk->s_fd < 0) { 118 err = -nl_syserr2nlerr(errno); 119 goto errout; 120 } 121 122 if (!(sk->s_flags & NL_SOCK_BUFSIZE_SET)) { 123 err = nl_socket_set_buffer_size(sk, 0, 0); 124 if (err < 0) 125 goto errout; 126 } 127 128 err = bind(sk->s_fd, (struct sockaddr*) &sk->s_local, 129 sizeof(sk->s_local)); 130 if (err < 0) { 131 err = -nl_syserr2nlerr(errno); 132 goto errout; 133 } 134 135 addrlen = sizeof(sk->s_local); 136 err = getsockname(sk->s_fd, (struct sockaddr *) &sk->s_local, 137 &addrlen); 138 if (err < 0) { 139 err = -nl_syserr2nlerr(errno); 140 goto errout; 141 } 142 143 if (addrlen != sizeof(sk->s_local)) { 144 err = -NLE_NOADDR; 145 goto errout; 146 } 147 148 if (sk->s_local.nl_family != AF_NETLINK) { 149 err = -NLE_AF_NOSUPPORT; 150 goto errout; 151 } 152 153 sk->s_proto = protocol; 154 155 return 0; 156 errout: 157 close(sk->s_fd); 158 sk->s_fd = -1; 159 160 return err; 161 } 162 163 /** 164 * Close/Disconnect netlink socket. 165 * @arg sk Netlink socket. 166 */ 167 void nl_close(struct nl_sock *sk) 168 { 169 if (sk->s_fd >= 0) { 170 close(sk->s_fd); 171 sk->s_fd = -1; 172 } 173 174 sk->s_proto = 0; 175 } 176 177 /** @} */ 178 179 /** 180 * @name Send 181 * @{ 182 */ 183 184 /** 185 * Send raw data over netlink socket. 186 * @arg sk Netlink socket. 187 * @arg buf Data buffer. 188 * @arg size Size of data buffer. 189 * @return Number of characters written on success or a negative error code. 190 */ 191 int nl_sendto(struct nl_sock *sk, void *buf, size_t size) 192 { 193 int ret; 194 195 ret = sendto(sk->s_fd, buf, size, 0, (struct sockaddr *) 196 &sk->s_peer, sizeof(sk->s_peer)); 197 if (ret < 0) 198 return -nl_syserr2nlerr(errno); 199 200 return ret; 201 } 202 203 /** 204 * Send netlink message with control over sendmsg() message header. 205 * @arg sk Netlink socket. 206 * @arg msg Netlink message to be sent. 207 * @arg hdr Sendmsg() message header. 208 * @return Number of characters sent on sucess or a negative error code. 209 */ 210 int nl_sendmsg(struct nl_sock *sk, struct nl_msg *msg, struct msghdr *hdr) 211 { 212 struct nl_cb *cb; 213 int ret; 214 215 struct iovec iov = { 216 .iov_base = (void *) nlmsg_hdr(msg), 217 .iov_len = nlmsg_hdr(msg)->nlmsg_len, 218 }; 219 220 hdr->msg_iov = &iov; 221 hdr->msg_iovlen = 1; 222 223 nlmsg_set_src(msg, &sk->s_local); 224 225 cb = sk->s_cb; 226 if (cb->cb_set[NL_CB_MSG_OUT]) 227 if (nl_cb_call(cb, NL_CB_MSG_OUT, msg) != NL_OK) 228 return 0; 229 230 if (sk->s_debug_tx_cb) { 231 nlmsg_set_proto(msg, sk->s_proto); 232 sk->s_debug_tx_cb(sk->s_debug_tx_priv, msg); 233 } 234 235 ret = sendmsg(sk->s_fd, hdr, 0); 236 if (ret < 0) 237 return -nl_syserr2nlerr(errno); 238 239 return ret; 240 } 241 242 243 /** 244 * Send netlink message. 245 * @arg sk Netlink socket. 246 * @arg msg Netlink message to be sent. 247 * @see nl_sendmsg() 248 * @return Number of characters sent on success or a negative error code. 249 */ 250 int nl_send(struct nl_sock *sk, struct nl_msg *msg) 251 { 252 struct sockaddr_nl *dst; 253 struct ucred *creds; 254 255 struct msghdr hdr = { 256 .msg_name = (void *) &sk->s_peer, 257 .msg_namelen = sizeof(struct sockaddr_nl), 258 }; 259 260 /* Overwrite destination if specified in the message itself, defaults 261 * to the peer address of the socket. 262 */ 263 dst = nlmsg_get_dst(msg); 264 if (dst->nl_family == AF_NETLINK) 265 hdr.msg_name = dst; 266 267 /* Add credentials if present. */ 268 creds = nlmsg_get_creds(msg); 269 if (creds != NULL) { 270 char buf[CMSG_SPACE(sizeof(struct ucred))]; 271 struct cmsghdr *cmsg; 272 273 hdr.msg_control = buf; 274 hdr.msg_controllen = sizeof(buf); 275 276 cmsg = CMSG_FIRSTHDR(&hdr); 277 cmsg->cmsg_level = SOL_SOCKET; 278 cmsg->cmsg_type = SCM_CREDENTIALS; 279 cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred)); 280 memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred)); 281 } 282 283 return nl_sendmsg(sk, msg, &hdr); 284 } 285 286 /** 287 * Send netlink message and check & extend header values as needed. 288 * @arg sk Netlink socket. 289 * @arg msg Netlink message to be sent. 290 * 291 * Checks the netlink message \c nlh for completness and extends it 292 * as required before sending it out. Checked fields include pid, 293 * sequence nr, and flags. 294 * 295 * @see nl_send() 296 * @return Number of characters sent or a negative error code. 297 */ 298 int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg) 299 { 300 struct nlmsghdr *nlh; 301 struct nl_cb *cb = sk->s_cb; 302 303 nlh = nlmsg_hdr(msg); 304 if (nlh->nlmsg_pid == 0) 305 nlh->nlmsg_pid = sk->s_local.nl_pid; 306 307 if (nlh->nlmsg_seq == 0) 308 nlh->nlmsg_seq = sk->s_seq_next++; 309 310 if (msg->nm_protocol == -1) 311 msg->nm_protocol = sk->s_proto; 312 313 nlh->nlmsg_flags |= NLM_F_REQUEST; 314 315 if (!(sk->s_flags & NL_NO_AUTO_ACK)) 316 nlh->nlmsg_flags |= NLM_F_ACK; 317 318 if (cb->cb_send_ow) 319 return cb->cb_send_ow(sk, msg); 320 else 321 return nl_send(sk, msg); 322 } 323 324 /** 325 * Send simple netlink message using nl_send_auto_complete() 326 * @arg sk Netlink socket. 327 * @arg type Netlink message type. 328 * @arg flags Netlink message flags. 329 * @arg buf Data buffer. 330 * @arg size Size of data buffer. 331 * 332 * Builds a netlink message with the specified type and flags and 333 * appends the specified data as payload to the message. 334 * 335 * @see nl_send_auto_complete() 336 * @return Number of characters sent on success or a negative error code. 337 */ 338 int nl_send_simple(struct nl_sock *sk, int type, int flags, void *buf, 339 size_t size) 340 { 341 int err; 342 struct nl_msg *msg; 343 344 msg = nlmsg_alloc_simple(type, flags); 345 if (!msg) 346 return -NLE_NOMEM; 347 348 if (buf && size) { 349 err = nlmsg_append(msg, buf, size, NLMSG_ALIGNTO); 350 if (err < 0) 351 goto errout; 352 } 353 354 355 err = nl_send_auto_complete(sk, msg); 356 errout: 357 nlmsg_free(msg); 358 359 return err; 360 } 361 362 /** @} */ 363 364 /** 365 * @name Receive 366 * @{ 367 */ 368 369 /** 370 * Receive data from netlink socket 371 * @arg sk Netlink socket. 372 * @arg nla Destination pointer for peer's netlink address. 373 * @arg buf Destination pointer for message content. 374 * @arg creds Destination pointer for credentials. 375 * 376 * Receives a netlink message, allocates a buffer in \c *buf and 377 * stores the message content. The peer's netlink address is stored 378 * in \c *nla. The caller is responsible for freeing the buffer allocated 379 * in \c *buf if a positive value is returned. Interrupted system calls 380 * are handled by repeating the read. The input buffer size is determined 381 * by peeking before the actual read is done. 382 * 383 * A non-blocking sockets causes the function to return immediately with 384 * a return value of 0 if no data is available. 385 * 386 * @return Number of octets read, 0 on EOF or a negative error code. 387 */ 388 int nl_recv(struct nl_sock *sk, struct sockaddr_nl *nla, 389 unsigned char **buf, struct ucred **creds) 390 { 391 int n; 392 int flags = 0; 393 static int page_size = 0; 394 struct iovec iov; 395 struct msghdr msg = { 396 .msg_name = (void *) nla, 397 .msg_namelen = sizeof(struct sockaddr_nl), 398 .msg_iov = &iov, 399 .msg_iovlen = 1, 400 .msg_control = NULL, 401 .msg_controllen = 0, 402 .msg_flags = 0, 403 }; 404 struct cmsghdr *cmsg; 405 406 if (sk->s_flags & NL_MSG_PEEK) 407 flags |= MSG_PEEK; 408 409 if (page_size == 0) 410 page_size = getpagesize() * 4; 411 412 iov.iov_len = page_size; 413 iov.iov_base = *buf = calloc(1, iov.iov_len); 414 if (!*buf) 415 return -nl_syserr2nlerr(errno); 416 417 if (sk->s_flags & NL_SOCK_PASSCRED) { 418 msg.msg_controllen = CMSG_SPACE(sizeof(struct ucred)); 419 msg.msg_control = calloc(1, msg.msg_controllen); 420 } 421 retry: 422 423 n = recvmsg(sk->s_fd, &msg, flags); 424 if (!n) 425 goto abort; 426 else if (n < 0) { 427 if (errno == EINTR) { 428 NL_DBG(3, "recvmsg() returned EINTR, retrying\n"); 429 goto retry; 430 } else if (errno == EAGAIN) { 431 NL_DBG(3, "recvmsg() returned EAGAIN, aborting\n"); 432 goto abort; 433 } else { 434 free(msg.msg_control); 435 free(*buf); 436 *buf = NULL; 437 return -nl_syserr2nlerr(errno); 438 } 439 } 440 441 if (iov.iov_len < (size_t) n || 442 msg.msg_flags & MSG_TRUNC) { 443 /* Provided buffer is not long enough, enlarge it 444 * and try again. */ 445 iov.iov_len *= 2; 446 iov.iov_base = *buf = realloc(*buf, iov.iov_len); 447 goto retry; 448 } else if (msg.msg_flags & MSG_CTRUNC) { 449 msg.msg_controllen *= 2; 450 msg.msg_control = realloc(msg.msg_control, msg.msg_controllen); 451 goto retry; 452 } else if (flags != 0) { 453 /* Buffer is big enough, do the actual reading */ 454 flags = 0; 455 goto retry; 456 } 457 458 if (msg.msg_namelen != sizeof(struct sockaddr_nl)) { 459 free(msg.msg_control); 460 free(*buf); 461 *buf = NULL; 462 return -NLE_NOADDR; 463 } 464 465 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { 466 if (cmsg->cmsg_level == SOL_SOCKET && 467 cmsg->cmsg_type == SCM_CREDENTIALS) { 468 *creds = calloc(1, sizeof(struct ucred)); 469 memcpy(*creds, CMSG_DATA(cmsg), sizeof(struct ucred)); 470 break; 471 } 472 } 473 474 free(msg.msg_control); 475 return n; 476 477 abort: 478 free(msg.msg_control); 479 free(*buf); 480 *buf = NULL; 481 return 0; 482 } 483 484 #define NL_CB_CALL(cb, type, msg) \ 485 do { \ 486 err = nl_cb_call(cb, type, msg); \ 487 switch (err) { \ 488 case NL_OK: \ 489 err = 0; \ 490 break; \ 491 case NL_SKIP: \ 492 goto skip; \ 493 case NL_STOP: \ 494 goto stop; \ 495 default: \ 496 goto out; \ 497 } \ 498 } while (0) 499 500 static int recvmsgs(struct nl_sock *sk, struct nl_cb *cb) 501 { 502 int n, err = 0, multipart = 0; 503 unsigned char *buf = NULL; 504 struct nlmsghdr *hdr; 505 struct sockaddr_nl nla = {0}; 506 struct nl_msg *msg = NULL; 507 struct ucred *creds = NULL; 508 509 continue_reading: 510 NL_DBG(3, "Attempting to read from %p\n", sk); 511 if (cb->cb_recv_ow) 512 n = cb->cb_recv_ow(sk, &nla, &buf, &creds); 513 else 514 n = nl_recv(sk, &nla, &buf, &creds); 515 516 if (n <= 0) 517 return n; 518 519 /* make clang analyzer happy */ 520 assert(n > 0 && buf); 521 522 NL_DBG(3, "recvmsgs(%p): Read %d bytes\n", sk, n); 523 524 hdr = (struct nlmsghdr *) buf; 525 while (nlmsg_ok(hdr, n)) { 526 NL_DBG(3, "recgmsgs(%p): Processing valid message...\n", sk); 527 528 nlmsg_free(msg); 529 msg = nlmsg_convert(hdr); 530 if (!msg) { 531 err = -NLE_NOMEM; 532 goto out; 533 } 534 535 nlmsg_set_proto(msg, sk->s_proto); 536 nlmsg_set_src(msg, &nla); 537 if (creds) 538 nlmsg_set_creds(msg, creds); 539 540 if (sk->s_debug_rx_cb) 541 sk->s_debug_rx_cb(sk->s_debug_rx_priv, msg); 542 543 /* Raw callback is the first, it gives the most control 544 * to the user and he can do his very own parsing. */ 545 if (cb->cb_set[NL_CB_MSG_IN]) 546 NL_CB_CALL(cb, NL_CB_MSG_IN, msg); 547 548 /* Sequence number checking. The check may be done by 549 * the user, otherwise a very simple check is applied 550 * enforcing strict ordering */ 551 if (cb->cb_set[NL_CB_SEQ_CHECK]) 552 NL_CB_CALL(cb, NL_CB_SEQ_CHECK, msg); 553 else if (hdr->nlmsg_seq != sk->s_seq_expect) { 554 if (cb->cb_set[NL_CB_INVALID]) 555 NL_CB_CALL(cb, NL_CB_INVALID, msg); 556 else { 557 err = -NLE_SEQ_MISMATCH; 558 goto out; 559 } 560 } 561 562 if (hdr->nlmsg_type == NLMSG_DONE || 563 hdr->nlmsg_type == NLMSG_ERROR || 564 hdr->nlmsg_type == NLMSG_NOOP || 565 hdr->nlmsg_type == NLMSG_OVERRUN) { 566 /* We can't check for !NLM_F_MULTI since some netlink 567 * users in the kernel are broken. */ 568 sk->s_seq_expect++; 569 NL_DBG(3, "recvmsgs(%p): Increased expected " \ 570 "sequence number to %d\n", 571 sk, sk->s_seq_expect); 572 } 573 574 if (hdr->nlmsg_flags & NLM_F_MULTI) 575 multipart = 1; 576 577 /* Other side wishes to see an ack for this message */ 578 if (hdr->nlmsg_flags & NLM_F_ACK) { 579 if (cb->cb_set[NL_CB_SEND_ACK]) 580 NL_CB_CALL(cb, NL_CB_SEND_ACK, msg); 581 else { 582 /* FIXME: implement */ 583 } 584 } 585 586 /* messages terminates a multpart message, this is 587 * usually the end of a message and therefore we slip 588 * out of the loop by default. the user may overrule 589 * this action by skipping this packet. */ 590 if (hdr->nlmsg_type == NLMSG_DONE) { 591 multipart = 0; 592 if (cb->cb_set[NL_CB_FINISH]) 593 NL_CB_CALL(cb, NL_CB_FINISH, msg); 594 } 595 596 /* Message to be ignored, the default action is to 597 * skip this message if no callback is specified. The 598 * user may overrule this action by returning 599 * NL_PROCEED. */ 600 else if (hdr->nlmsg_type == NLMSG_NOOP) { 601 if (cb->cb_set[NL_CB_SKIPPED]) 602 NL_CB_CALL(cb, NL_CB_SKIPPED, msg); 603 else 604 goto skip; 605 } 606 607 /* Data got lost, report back to user. The default action is to 608 * quit parsing. The user may overrule this action by retuning 609 * NL_SKIP or NL_PROCEED (dangerous) */ 610 else if (hdr->nlmsg_type == NLMSG_OVERRUN) { 611 if (cb->cb_set[NL_CB_OVERRUN]) 612 NL_CB_CALL(cb, NL_CB_OVERRUN, msg); 613 else { 614 err = -NLE_MSG_OVERFLOW; 615 goto out; 616 } 617 } 618 619 /* Message carries a nlmsgerr */ 620 else if (hdr->nlmsg_type == NLMSG_ERROR) { 621 struct nlmsgerr *e = nlmsg_data(hdr); 622 623 if (hdr->nlmsg_len < (unsigned) nlmsg_msg_size(sizeof(*e))) { 624 /* Truncated error message, the default action 625 * is to stop parsing. The user may overrule 626 * this action by returning NL_SKIP or 627 * NL_PROCEED (dangerous) */ 628 if (cb->cb_set[NL_CB_INVALID]) 629 NL_CB_CALL(cb, NL_CB_INVALID, msg); 630 else { 631 err = -NLE_MSG_TRUNC; 632 goto out; 633 } 634 } else if (e->error) { 635 /* Error message reported back from kernel. */ 636 if (cb->cb_err) { 637 err = cb->cb_err(&nla, e, 638 cb->cb_err_arg); 639 if (err < 0) 640 goto out; 641 else if (err == NL_SKIP) 642 goto skip; 643 else if (err == NL_STOP) { 644 err = -nl_syserr2nlerr(e->error); 645 goto out; 646 } 647 } else { 648 err = -nl_syserr2nlerr(e->error); 649 goto out; 650 } 651 } else if (cb->cb_set[NL_CB_ACK]) 652 NL_CB_CALL(cb, NL_CB_ACK, msg); 653 } else { 654 /* Valid message (not checking for MULTIPART bit to 655 * get along with broken kernels. NL_SKIP has no 656 * effect on this. */ 657 if (cb->cb_set[NL_CB_VALID]) 658 NL_CB_CALL(cb, NL_CB_VALID, msg); 659 } 660 skip: 661 hdr = nlmsg_next(hdr, &n); 662 } 663 664 nlmsg_free(msg); 665 free(buf); 666 free(creds); 667 buf = NULL; 668 msg = NULL; 669 creds = NULL; 670 671 if (multipart) { 672 /* Multipart message not yet complete, continue reading */ 673 goto continue_reading; 674 } 675 stop: 676 err = 0; 677 out: 678 nlmsg_free(msg); 679 free(buf); 680 free(creds); 681 682 return err; 683 } 684 685 /** 686 * Receive a set of messages from a netlink socket. 687 * @arg sk Netlink socket. 688 * @arg cb set of callbacks to control behaviour. 689 * 690 * Repeatedly calls nl_recv() or the respective replacement if provided 691 * by the application (see nl_cb_overwrite_recv()) and parses the 692 * received data as netlink messages. Stops reading if one of the 693 * callbacks returns NL_STOP or nl_recv returns either 0 or a negative error code. 694 * 695 * A non-blocking sockets causes the function to return immediately if 696 * no data is available. 697 * 698 * @return 0 on success or a negative error code from nl_recv(). 699 */ 700 int nl_recvmsgs(struct nl_sock *sk, struct nl_cb *cb) 701 { 702 if (cb->cb_recvmsgs_ow) 703 return cb->cb_recvmsgs_ow(sk, cb); 704 else 705 return recvmsgs(sk, cb); 706 } 707 708 709 static int ack_wait_handler(struct nl_msg *msg, void *arg) 710 { 711 return NL_STOP; 712 } 713 714 /** 715 * Wait for ACK. 716 * @arg sk Netlink socket. 717 * @pre The netlink socket must be in blocking state. 718 * 719 * Waits until an ACK is received for the latest not yet acknowledged 720 * netlink message. 721 */ 722 int nl_wait_for_ack(struct nl_sock *sk) 723 { 724 int err; 725 struct nl_cb *cb; 726 727 cb = nl_cb_clone(sk->s_cb); 728 if (cb == NULL) 729 return -NLE_NOMEM; 730 731 nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_wait_handler, NULL); 732 err = nl_recvmsgs(sk, cb); 733 nl_cb_put(cb); 734 735 return err; 736 } 737 738 /** @} */ 739 740 /** @} */ 741
This page was automatically generated by LXR 0.3.1. • OpenWrt